Microservices - Grundlagen flexibler Softwarearchitekturen
von: Eberhard Wolff
dpunkt, 2015
ISBN: 9783864918421
Sprache: Deutsch
386 Seiten, Download: 5724 KB
Format: EPUB, PDF, auch als Online-Lesen
geeignet für:
Typ: A (einfacher Zugriff)
| Inhaltsverzeichnis | 5 | ||
| 1 Vorwort | 11 | ||
| 1.1 Überblick über Microservices | 12 | ||
| 1.2 Warum Microservices? | 13 | ||
| Abb. 1–1 Vorteile von Microservices | 13 | ||
| Teil I Motivation und Grundlagen | 17 | ||
| 2 Einleitung | 19 | ||
| 2.1 Überblick über das Buch | 19 | ||
| 2.2 Für wen ist das Buch? | 19 | ||
| 2.3 Übersicht über die Kapitel | 20 | ||
| 2.4 Essays | 22 | ||
| 2.5 Pfade durch das Buch | 22 | ||
| Tab. 2–1 Pfade durch das Buch | 22 | ||
| 2.6 Danksagung | 23 | ||
| 2.7 Links & Literatur | 23 | ||
| 3 Microservice-Szenarien | 25 | ||
| 3.1 Eine E-Commerce-Legacy-Anwendung modernisieren | 25 | ||
| Szenario | 25 | ||
| Gründe für Microservices | 25 | ||
| Abb. 3–1 Teams bremsen sich durch den Monolithen gegenseitig aus. | 27 | ||
| Vorgehen | 27 | ||
| Herausforderungen | 28 | ||
| Abb. 3–2 Entkoppelte Arbeit durch Microservices | 29 | ||
| Nutzen | 30 | ||
| Bewertung | 31 | ||
| Amazon macht es schon lange | 32 | ||
| 3.2 Ein neues Signalsystem entwickeln | 33 | ||
| Szenario | 33 | ||
| Abb. 3–3 Überblick über das Signalsystem | 33 | ||
| Gründe für Microservices | 33 | ||
| Herausforderungen | 35 | ||
| Nutzen | 35 | ||
| Bewertung | 36 | ||
| 3.3 Fazit | 36 | ||
| Wesentliche Punkte | 37 | ||
| Teil II Microservices: Was, warum und warum vielleicht nicht? | 39 | ||
| 4 Was sind Microservices? | 41 | ||
| 4.1 Größe eines Microservice | 41 | ||
| Abb. 4–1 Einflussfaktoren für die Größe eines Microservice | 48 | ||
| Selber ausprobieren und experimentieren | 49 | ||
| 4.2 Das Gesetz von Conway | 49 | ||
| Abb. 4–2 Technische Aufteilung des Projekts | 50 | ||
| Abb. 4–3 Aufteilung nach Fachlichkeiten | 52 | ||
| Selber ausprobieren und experimentieren | 54 | ||
| 4.3 Domain-Driven Design und Bounded Context | 54 | ||
| Bounded Context: Ein Beispiel | 57 | ||
| Abb. 4–4 Beispiel für Bounded Contexts | 57 | ||
| Warum Sie ein kanonisches Datenmodell lieber vermeiden sollten von Stefan Tilkov, innoQ GmbH | 59 | ||
| Abb. 4–5 Kommunikationsbedarf verschiedener Kollabora- tionsmöglichkeiten | 63 | ||
| Selber ausprobieren und experimentieren | 64 | ||
| 4.4 Microservice: Mit UI? | 64 | ||
| 4.5 Fazit | 66 | ||
| Wesentliche Punkte | 67 | ||
| Selber ausprobieren und experimentieren | 67 | ||
| 4.6 Links & Literatur | 68 | ||
| 5 Gründe für Microservices | 69 | ||
| 5.1 Technische Vorteile | 69 | ||
| Ein Beispiel für Microservices und Legacy | 72 | ||
| Abb. 5–1 Beispiel für Legacy-Integration | 72 | ||
| Abb. 5–2 Continuous-Delivery- Pipeline | 73 | ||
| 5.2 Organisatorische Vorteile | 77 | ||
| Die Scala-Entscheidung | 78 | ||
| 5.3 Vorteile aus Geschäftssicht | 79 | ||
| Abb. 5–3 Mehrere Anforderungsströme | 80 | ||
| 5.4 Fazit | 81 | ||
| Wesentliche Punkte | 81 | ||
| Selber ausprobieren und experimentieren | 82 | ||
| 5.5 Links & Literatur | 82 | ||
| 6 Herausforderungen bei Microservices | 83 | ||
| 6.1 Technische Herausforderungen | 83 | ||
| Abb. 6–1 Latenz bei einem Aufruf über das Netz | 84 | ||
| Abb. 6–2 Verteilte Drei-Schicht-Architektur | 84 | ||
| Auswirkungen von Code-Abhängigkeiten | 86 | ||
| 6.2 Architektur | 87 | ||
| 6.3 Infrastruktur und Betrieb | 90 | ||
| 6.4 Fazit | 91 | ||
| Wesentliche Punkte | 92 | ||
| Selber ausprobieren und experimentieren | 92 | ||
| 6.5 Links & Literatur | 92 | ||
| 7 Microservices und SOA | 93 | ||
| 7.1 Was ist SOA? | 93 | ||
| Abb. 7–1 Überblick über eine SOA-Landschaft | 94 | ||
| Abb. 7–2 Kommunikation in einer SOA-Architektur | 96 | ||
| 7.2 Unterschiede zwischen SOA und Microservices | 99 | ||
| Abb. 7–3 CRM als Sammlung von Microservices | 100 | ||
| Abb. 7–4 Kommunikation bei Microservices | 103 | ||
| Abb. 7–5 SOA zur Migration von Microservices | 103 | ||
| 7.3 Fazit | 104 | ||
| Tab. 7–1 Unterschiede zwischen SOA und Microservices | 104 | ||
| Wesentliche Punkte | 105 | ||
| Selber ausprobieren und experimentieren | 105 | ||
| 7.4 Links & Literatur | 106 | ||
| Teil III Microservices umsetzen | 107 | ||
| 8 Architektur von Microservice-Systemen | 111 | ||
| 8.1 Fachliche Architektur | 111 | ||
| Abb. 8–1 Zyklische Abhängigkeit | 115 | ||
| 8.2 Architekturmanagement | 116 | ||
| Abb. 8–2 Screenshot des Architekturmanagement- Werkzeugs Structure 101 | 116 | ||
| Abb. 8–3 Eine beispielhafte Context Map | 120 | ||
| Selber ausprobieren und experimentieren | 121 | ||
| 8.3 Techniken zum Anpassen der Architektur | 121 | ||
| Änderungen der Gesamtarchitektur | 122 | ||
| Gemeinsame Bibliothek | 123 | ||
| Abb. 8–4 Gemeinsame Bibliothek | 123 | ||
| Code übertragen | 125 | ||
| Abb. 8–5 Code übertragen | 126 | ||
| Gemeinsamer Service | 127 | ||
| Abb. 8–6 Gemeinsame Microservices | 127 | ||
| Neuen Microservice erzeugen | 128 | ||
| Abb. 8–7 Neuen Microservice erzeugen | 128 | ||
| Neu schreiben | 129 | ||
| Microservice-Systeme sind schwer änderbar | 129 | ||
| Selber ausprobieren und experimentieren | 130 | ||
| 8.4 Microservice-Systeme weiterentwickeln | 130 | ||
| Abb. 8–8 Start Big: Aus wenigen Microservices entstehen zunehmend mehr Microservices. | 132 | ||
| Verpasse nicht den Absprung oder: Wie vermeidet man die Erosion eines Microservice? von Lars Gentsch, E-Post Development GmbH | 134 | ||
| Einbindung neuer Funktionalität | 135 | ||
| Was passiert hier mit dem Microservice? | 135 | ||
| Kriterien für einen neuen statt der Erweiterung eines bestehenden Service: | 136 | ||
| Woran ist zu erkennen, wenn der Absprung zu einem neuen Microservice nicht geschafft wurde? | 136 | ||
| Fazit | 137 | ||
| 8.5 Microservice und Legacy-Anwendung | 137 | ||
| Legacy-Anwendung ergänzen | 138 | ||
| Abb. 8–9 Legacy-Anwendung mit Message Router ergänzen | 139 | ||
| Versteckte Abhängigkeiten von Oliver Wehrens, E-Post Development GmbH | 141 | ||
| Die Datenbank | 142 | ||
| Integration über UI und Datenreplikation | 144 | ||
| Bewertung | 145 | ||
| Legacy = Infrastruktur | 146 | ||
| Selber ausprobieren und experimentieren | 146 | ||
| 8.6 Event-driven Architecture | 147 | ||
| Abb. 8–10 Aufrufe zwischen Microservices | 147 | ||
| Abb. 8–11 Event-driven Architecture | 147 | ||
| 8.7 Technische Architektur | 148 | ||
| Abb. 8–12 Sidecar macht alle Standardtechnologien über eine einfache Schnittstelle verfügbar. | 150 | ||
| Selber ausprobieren und experimentieren | 151 | ||
| 8.8 Konfiguration und Koordination | 151 | ||
| 8.9 Service Discovery | 153 | ||
| 8.10 Load Balancing | 156 | ||
| Abb. 8–13 Proxy-basierter Load Balancer | 157 | ||
| Abb. 8–14 Load Balancing mit Service Discovery | 158 | ||
| Abb. 8–15 Client-seitiges Load Balancing | 159 | ||
| 8.11 Skalierbarkeit | 160 | ||
| Abb. 8–16 Horizontale und vertikale Skalierung | 160 | ||
| 8.12 Sicherheit | 163 | ||
| Abb. 8–17 Das OAuth2-Protokoll | 164 | ||
| 8.13 Dokumentation und Metadaten | 171 | ||
| 8.14 Fazit | 172 | ||
| Wesentliche Punkte | 174 | ||
| 8.15 Links und Literatur | 175 | ||
| 9 Integration und Kommunikation | 177 | ||
| Abb. 9–1 Integration von Microservices auf unterschiedlichen Ebenen | 177 | ||
| 9.1 Web und UI | 177 | ||
| SPA pro Microservice | 179 | ||
| Abb. 9–2 Microservices mit Single-Page-Apps | 179 | ||
| Eine Single-Page-App für alle Microservices | 180 | ||
| Abb. 9–3 Enge Integration von Microservices in einer Single-Page-App | 181 | ||
| HTML-Anwendungen | 182 | ||
| Abb. 9–4 HTML-Oberflächen mit Asset-Server | 183 | ||
| Frontend-Server | 184 | ||
| Abb. 9–5 Integration mit einem Frontend-Server | 185 | ||
| Mobile Clients und Rich Clients | 186 | ||
| Abb. 9–6 Mobile App/Rich Client: ein Deployment-Monolith, der mehrere Microservices integriert | 187 | ||
| Abb. 9–7 Mobile App bzw. Rich Client mit eigenem Backend | 188 | ||
| Selber ausprobieren und experimentieren | 189 | ||
| 9.2 REST | 189 | ||
| 9.3 SOAP und RPC | 192 | ||
| 9.4 Messaging | 193 | ||
| Abb. 9–8 Transaktionen und Messaging | 195 | ||
| Selber ausprobieren und experimentieren | 197 | ||
| 9.5 Datenreplikation | 197 | ||
| Selber ausprobieren und experimentieren | 200 | ||
| 9.6 Schnittstellen: intern und extern | 200 | ||
| 9.7 Fazit | 203 | ||
| Wesentliche Punkte | 205 | ||
| 9.8 Links & Literatur | 205 | ||
| 10 Architektur eines Microservice | 207 | ||
| 10.1 Fachliche Architektur | 207 | ||
| 10.2 CQRS | 209 | ||
| Abb. 10–1 Prinzipieller Aufbau eines CQRS-Systems | 209 | ||
| 10.3 Event Sourcing | 211 | ||
| Abb. 10–2 Event Sourcing im Überblick | 212 | ||
| Selber ausprobieren und experimentieren | 213 | ||
| 10.4 Hexagonale Architekturen | 213 | ||
| Abb. 10–3 Überblick hexagonale Architektur | 214 | ||
| Abb. 10–4 Bestellung als Microservice mit einer hexagonalen Architektur | 216 | ||
| Selber ausprobieren und experimentieren | 217 | ||
| 10.5 Resilience und Stabilität | 217 | ||
| Abb. 10–5 Stabilität bei Microservices | 221 | ||
| Selber ausprobieren und experimentieren | 222 | ||
| 10.6 Technische Architektur | 222 | ||
| Selber ausprobieren und experimentieren | 225 | ||
| 10.7 Fazit | 225 | ||
| Wesentliche Punkte | 226 | ||
| 10.8 Links & Literatur | 226 | ||
| 11 Testen von Microservices und Microservice-Systemen | 227 | ||
| 11.1 Warum testen? | 227 | ||
| 11.2 Wie testen? | 229 | ||
| Abb. 11–1 Testpyramide: das Optimum | 231 | ||
| Abb. 11–2 Test-Eiswaffel: Oft die traurige Realität | 232 | ||
| Selber ausprobieren und experimentieren | 233 | ||
| 11.3 Risiken beim Deployment minimieren | 234 | ||
| 11.4 Tests des Gesamtsystems | 235 | ||
| Abb. 11–3 Testpyramide für Microservices | 236 | ||
| Abb. 11–4 Integrationstests am Ende der Deployment-Pipelines | 237 | ||
| 11.5 Legacy-Anwendungen mit Microservices testen | 238 | ||
| Abb. 11–5 Verlagern der Tests | 239 | ||
| Abb. 11–6 Legacy-Anwendung in der Continuous-Delivery- Pipeline der Microservices | 240 | ||
| Abb. 11–7 Microservices in der Continuous-Delivery- Pipeline der Legacy- Anwendung | 241 | ||
| 11.6 Tests einzelner Microservices | 241 | ||
| Selber ausprobieren und experimentieren | 243 | ||
| 11.7 Consumer-Driven Contract Test | 243 | ||
| Abb. 11–8 Unterschiedliche Verträge zwischen Nutzer und Anbieter | 245 | ||
| Selber ausprobieren und experimentieren | 247 | ||
| 11.8 Technische Standards testen | 247 | ||
| 11.9 Fazit | 249 | ||
| Wesentliche Punkte | 250 | ||
| 11.10 Links & Literatur | 250 | ||
| 12 Betrieb und Continuous Delivery von Microservices | 251 | ||
| 12.1 Herausforderungen beim Betrieb von Microservices | 251 | ||
| 12.2 Logging | 254 | ||
| Abb. 12–1 Aufbau einer ELK-Log-Infrastruktur | 256 | ||
| Selber ausprobieren und experimentieren | 259 | ||
| 12.3 Monitoring | 259 | ||
| Abb. 12–2 Stakeholder mit eigenen Daten | 262 | ||
| Abb. 12–3 Bestandteile einer Monitoring-Lösung | 265 | ||
| Selber ausprobieren und experimentieren | 266 | ||
| 12.4 Deployment | 266 | ||
| Gemeinsames oder getrenntes Deployment? von Jörg Müller, Hypoport AG | 270 | ||
| 12.5 Steuerung | 272 | ||
| 12.6 Infrastrukturen | 273 | ||
| Abb. 12–4 Dockers Dateisysteme | 276 | ||
| Selber ausprobieren und experimentieren | 277 | ||
| 12.7 Fazit | 279 | ||
| Wesentliche Punkte | 280 | ||
| 12.8 Link & Literatur | 281 | ||
| 13 Organisatorische Auswirkungen der Architektur | 283 | ||
| 13.1 Organisatorische Vorteile von Microservices | 283 | ||
| Abb. 13–1 Deployment-Monolith | 285 | ||
| Abb. 13–2 Aufteilung in Microservices | 286 | ||
| 13.2 Alternativer Umgang mit dem Gesetz von Conway | 287 | ||
| Selber ausprobieren und experimentieren | 290 | ||
| 13.3 Spielräume schaffen: Mikro- und Makro-Architektur | 291 | ||
| Abb. 13–3 Technologie: Makro-/Mikro-Architektur | 295 | ||
| Abb. 13–4 Betrieb: Makro-/Mikro-Architektur | 295 | ||
| Abb. 13–5 Fachliche Architektur: Makro-/Mikro-Architektur | 296 | ||
| Abb. 13–6 Tests: Makro-/Mikro-Architektur | 296 | ||
| 13.4 Technische Führung | 297 | ||
| Selber ausprobieren und experimentieren | 298 | ||
| 13.5 DevOps | 298 | ||
| Wenn Microservices auf klassische IT-Organisationen treffen von Alexander Heusingfeld, innoQ Deutschland GmbH | 300 | ||
| Pets vs. Cattle | 300 | ||
| Wir und Ihr | 301 | ||
| Entwicklung vs. Test vs. Betrieb: Perspektivenwechsel | 302 | ||
| Für Ops gibt es nie eine »ganz grüne Wiese« | 302 | ||
| Fazit | 303 | ||
| 13.6 Schnittstelle zu den Fachbereichen | 303 | ||
| Abb. 13–7 Fachbereich, Product Owner und Microservices | 304 | ||
| 13.7 Wiederverwendbarer Code | 305 | ||
| Selber ausprobieren und experimentieren | 308 | ||
| 13.8 Microservices ohne Organisationsänderung? | 309 | ||
| Selber ausprobieren und experimentieren | 311 | ||
| 13.9 Fazit | 311 | ||
| Wesentliche Punkte | 313 | ||
| 13.10 Links & Literatur | 313 | ||
| Teil IV Technologien | 315 | ||
| 14 Ein Beispiel für eine Microservices-Architektur | 317 | ||
| 14.1 Fachliche Architektur | 318 | ||
| Abb. 14–1 Architektur des Beispiels | 318 | ||
| 14.2 Basistechnologien | 320 | ||
| Listing 14–1 Ein einfacher Spring-Boot-REST-Service | 322 | ||
| Abb. 14–2 Überblick über Spring Cloud | 322 | ||
| Selber ausprobieren und experimentieren | 324 | ||
| 14.3 Build | 324 | ||
| Listing 14–2 Ausschnitt aus pom.xml mit Abhängigkeiten | 325 | ||
| Selber ausprobieren und experimentieren | 325 | ||
| 14.4 Deployment mit Docker | 326 | ||
| Listing 14–3 Dockerfile für einen Microservice aus dem Beispiel | 326 | ||
| 14.5 Vagrant | 327 | ||
| Abb. 14–3 Funktionsweise von Vagrant | 327 | ||
| Listing 14–4 Vagrantfile aus der Beispielanwendung | 329 | ||
| Abb. 14–4 Netzwerk und Ports in der Beispielanwendung | 330 | ||
| Selber ausprobieren und experimentieren | 330 | ||
| 14.6 Docker Machine | 332 | ||
| Abb. 14–5 Docker Machine | 333 | ||
| 14.7 Docker Compose | 334 | ||
| Listing 14–5 Docker-Compose- Konfiguration für die Beispielanwendung | 334 | ||
| Abb. 14–6 Netzwerk bei Docker Compose | 335 | ||
| Selber ausprobieren und experimentieren | 336 | ||
| 14.8 Service Discovery | 336 | ||
| Listing 14–6 Ausschnitt aus application.properties mit Eureka-Konfiguration | 338 | ||
| Listing 14–7 Eureka-Server | 338 | ||
| Abb. 14–7 Eureka-Dashboard | 338 | ||
| 14.9 Kommunikation | 339 | ||
| Abb. 14–8 Zuul-Proxy in der Beispielanwendung | 340 | ||
| Selber ausprobieren und experimentieren | 341 | ||
| 14.10 Resilience | 341 | ||
| Listing 14–8 Beispiel für eine mit Hystrix abgesicherte Methode | 342 | ||
| Abb. 14–9 Beispiel für ein Hystrix-Dashboard | 343 | ||
| Abb. 14–10 Hystrix-Daten mit Turbine konsolidieren | 343 | ||
| Listing 14–9 Konfiguration application.yml | 344 | ||
| Selber ausprobieren und experimentieren | 344 | ||
| 14.11 Load Balancing | 345 | ||
| Listing 14–10 Ermitteln eines Servers mit Ribbon Load Balancing | 345 | ||
| Listing 14–11 Nutzung von Ribbon mit dem RestTemplate | 346 | ||
| Selber ausprobieren und experimentieren | 346 | ||
| 14.12 Integration anderer Technologien | 346 | ||
| 14.13 Tests | 347 | ||
| Selber ausprobieren und experimentieren | 349 | ||
| Erfahrungen mit JVM-basierten Microservices in der Amazon Cloud von Sascha Möllering, zanox AG | 349 | ||
| Fazit | 351 | ||
| 14.14 Fazit | 352 | ||
| Wesentliche Punkte | 352 | ||
| Selber ausprobieren und experimentieren | 353 | ||
| 14.15 Links & Literatur | 353 | ||
| 15 Technologien für Nanoservices | 355 | ||
| 15.1 Warum Nanoservices? | 356 | ||
| 15.2 Definition Nanoservice | 358 | ||
| 15.3 Amazon Lambda | 359 | ||
| Selber ausprobieren und experimentieren | 361 | ||
| 15.4 OSGi | 362 | ||
| Listing 15–1 Ein OSGi MANIFEST.MF | 362 | ||
| Abb. 15–1 OSGi-Service, Implementierung und Schnittstelle | 363 | ||
| Selber ausprobieren und experimentieren | 365 | ||
| 15.5 Java EE | 365 | ||
| Abb. 15–2 Beispielanwendung mit Java-EE-Microservices | 367 | ||
| Selber ausprobieren und experimentieren | 368 | ||
| 15.6 Vert.x | 368 | ||
| Listing 15–2 Einfaches Java-Vert.x- Echo-Verticle | 369 | ||
| Listing 15–3 Einfaches JavaScript- Vert.x-Echo-Verticle | 369 | ||
| Selber ausprobieren und experimentieren | 370 | ||
| 15.7 Erlang | 370 | ||
| Abb. 15–3 Kommunikation zwischen Erlang-Prozessen | 371 | ||
| Listing 15–4 Ein Erlang-Echo-Server | 371 | ||
| Abb. 15–4 Überwachung in Erlang | 372 | ||
| Selber ausprobieren und experimentieren | 373 | ||
| 15.8 Seneca | 373 | ||
| Listing 15–5 Seneca-Server | 374 | ||
| Listing 15–6 Seneca-Client | 374 | ||
| Selber ausprobieren und experimentieren | 375 | ||
| 15.9 Fazit | 376 | ||
| Tab. 15–1 Bewertung der Technologien bezüglich der Eignung für Nanoservices | 377 | ||
| Wichtigste Punkte | 377 | ||
| 15.10 Links und Literatur | 378 | ||
| 16 Wie mit Microservices loslegen? | 379 | ||
| 16.1 Warum Microservices? | 379 | ||
| 16.2 Wege zu Microservices | 380 | ||
| 16.3 Microservice: Hype oder Realität? | 381 | ||
| 16.4 Fazit | 382 | ||
| Selber ausprobieren und experimentieren | 382 | ||
| Index | 383 | ||
| www.dpunkt.de | 0 |
