O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Microservices - Konzeption und Design

Book Description

  • Feingranulare Systeme mit Microservices aufbauen
  • Design, Entwicklung, Deployment, Testen und Monitoring
  • Sicherheitsaspekte, Authentifizierung und Autorisierung

Verteilte Systeme haben sich in den letzten Jahren stark verändert: Große monolithische Architekturen werden zunehmend in viele kleine, eigenständige Microservices aufgespalten. Aber die Entwicklung solcher Systeme bringt Herausforderungen ganz eigener Art mit sich. Dieses Buch richtet sich an Softwareentwickler, die sich über die zielführenden Aspekte von Microservice-Systemen wie Design, Entwicklung, Testen, Deployment und Monitoring informieren möchten.

Sam Newman veranschaulicht und konkretisiert seine ganzheitliche Betrachtung der grundlegenden Konzepte von Microservice-Architekturen anhand zahlreicher praktischer Beispiele und Ratschläge. Er geht auf die Themen ein, mit denen sich Systemarchitekten und Administratoren bei der Einrichtung, Verwaltung und Entwicklung dieser Architekturen in jedem Fall auseinandersetzen müssen.

Aus dem Inhalt:
  • Vorteile von Microservices
  • Gestaltung von Services
  • Ausrichtung der Systemarchitektur an der Organisationsstruktur
  • Möglichkeiten zur Integration von Services
  • Schrittweise Aufspaltung einer monolithischen Codebasis
  • Deployment einzelner Microservices mittels Continuous Integration
  • Testen und Monitoring verteilter Systeme
  • Sicherheitsaspekte
  • Authentifizierung und Autorisierung zwischen Benutzer und Service bzw. zwischen Services untereinander
  • Skalierung von Microservice-Architekturen
»Microservice-Architekturen besitzen viele interessante Eigenschaften, allerdings sind bei der Umstellung so einige Fallstricke zu beachten. Dieses Buch wird Ihnen helfen herauszufinden, ob Microservices für Ihre Zwecke geeignet sind und zeigt Ihnen, wie Sie die Fallstricke umgehen können.«
Martin Fowler, Chief Scientist, ThoughtWorks

Table of Contents

  1. Impressum
  2. Einleitung
  3. Über den Autor
  4. Kapitel 1: Microservices
    1. 1.1 Was sind Microservices?
      1. 1.1.1 Klein und darauf spezialisiert, eine bestimmte Aufgabe richtig gut zu erledigen
      2. 1.1.2 Eigenständigkeit
    2. 1.2 Die wichtigsten Vorteile​
      1. 1.2.1 Verschiedenartige Technologien
      2. 1.2.2 Belastbarkeit​
      3. 1.2.3 Skalierung​
      4. 1.2.4 Komfortables Deployment​
      5. 1.2.5 Betriebliche Abstimmung
      6. 1.2.6 Modularer Aufbau
      7. 1.2.7 Austauschbarkeit
    3. 1.3 Was ist mit serviceorientierten Architekturen?
    4. 1.4 Weitere Verfahren zur Aufspaltung
      1. 1.4.1 Programmbibliotheken
      2. 1.4.2 Module
    5. 1.5 Kein Patentrezept
    6. 1.6 Fazit
  5. Kapitel 2: Der fortentwickelte Systemarchitekt
    1. 2.1 Unangebrachte Vergleiche
    2. 2.2 Das Zukunftsbild eines Systemarchitekten
    3. 2.3 Zoneneinteilung
    4. 2.4 Ein grundsätzlicher Ansatz
      1. 2.4.1 Strategische Ziele
      2. 2.4.2 Prinzipien
      3. 2.4.3 Praktiken
      4. 2.4.4 Prinzipien und Praktiken vereinigen
      5. 2.4.5 Ein Praxisbeispiel
    5. 2.5 Mindestvorgaben
      1. 2.5.1 Monitoring
      2. 2.5.2 Schnittstellen
      3. 2.5.3 Architektonische Sicherheit​
    6. 2.6 Lenkung durch Code
      1. 2.6.1 Musterbeispiele​
      2. 2.6.2 Maßgeschneiderte Servicevorlagen​
    7. 2.7 Technische Schulden​
    8. 2.8 Ausnahmebehandlung
    9. 2.9 Governance und Steuerung aus der Mitte
    10. 2.10 Aufbau eines Entwicklerteams
    11. 2.11 Fazit
  6. Kapitel 3: Gestaltung von Services
    1. 3.1 Kurz vorgestellt: MusicCorp
    2. 3.2 Wodurch zeichnet sich ein guter Service aus?
      1. 3.2.1 Lose Kopplung​​
      2. 3.2.2 Hochgradige Geschlossenheit​
    3. 3.3 Begrenzter Kontext
      1. 3.3.1 Geteilte und verborgene Modelle
      2. 3.3.2 Module und Services
      3. 3.3.3 Verfrühte Aufteilung
    4. 3.4 Funktionalitäten des Kontexts
    5. 3.5 Schildkröten bis ganz unten
    6. 3.6 Kommunikation unter geschäftlichen Aspekten
    7. 3.7 Der technische Rahmen
    8. 3.8 Fazit
  7. Kapitel 4: Integration
    1. 4.1 Die Suche nach der optimalen Integrationsmethode
      1. 4.1.1 Zu Ausfällen führende Änderungen vermeiden
      2. 4.1.2 Technologieunabhängige APIs verwenden
      3. 4.1.3 Services für den Nutzer vereinfachen
      4. 4.1.4 Implementierungsdetails verbergen
    2. 4.2 Kundendatensätze
    3. 4.3 Gemeinsame Nutzung der Datenbank
    4. 4.4 Synchrone kontra asynchrone Kommunikation
    5. 4.5 Orchestrierung kontra Choreografie
    6. 4.6 Aufruf entfernter Prozeduren (RPC)
      1. 4.6.1 Kopplung von Technologien
      2. 4.6.2 Lokale Aufrufe sind keine entfernten Aufrufe
      3. 4.6.3 Fragilität
      4. 4.6.4 Ist RPC ein Übel?
    7. 4.7 REST
      1. 4.7.1 REST und HTTP
      2. 4.7.2 HATEOAS​
      3. 4.7.3 JSON, XML oder etwas anderes?
      4. 4.7.4 Vorsicht vor zu viel Komfort
      5. 4.7.5 Nachteile von REST über HTTP
    8. 4.8 Implementierung asynchroner ereignisgesteuerter Kollaboration
      1. 4.8.1 Verfügbare Technologien
      2. 4.8.2 Die Kompliziertheit asynchroner Architekturen
    9. 4.9 Services als Zustandsautomaten
    10. 4.10 Reactive Extensions
    11. 4.11 DRY und die Gefahren der Wiederverwendung von Code im Microservices-Umfeld
      1. 4.11.1 Client-Bibliotheken
    12. 4.12 Zugriff über Referenzen
    13. 4.13 Versionierung
      1. 4.13.1 Solange wie möglich hinauszögern
      2. 4.13.2 Zu Ausfällen führende Änderungen rechtzeitig erkennen
      3. 4.13.3 Verwendung semantischer Versionierung
      4. 4.13.4 Mehrere Endpunkte gleichzeitig betreiben
      5. 4.13.5 Mehrere Serviceversionen gleichzeitig betreiben
    14. 4.14 Benutzerschnittstellen
      1. 4.14.1 Zunehmend digital
      2. 4.14.2 Voraussetzungen
      3. 4.14.3 Aufbau der API
      4. 4.14.4 Bausteine der Benutzeroberfläche
      5. 4.14.5 Back-Ends für Front-Ends
      6. 4.14.6 Ein Hybridansatz
    15. 4.15 Integration der Software von Drittherstellern
      1. 4.15.1 Fehlende Entscheidungsmöglichkeiten
      2. 4.15.2 Anpassungen
      3. 4.15.3 Integrationswirrwarr
      4. 4.15.4 Auf sich selbst gestellt
      5. 4.15.5 Das Strangler-Pattern
    16. 4.16 Fazit
  8. Kapitel 5: Die Aufspaltung des Monolithen
    1. 5.1 Seams
    2. 5.2 Aufspaltung von MusicCorp
    3. 5.3 Gründe zur Aufspaltung des Monolithen
      1. 5.3.1 Tempo der Änderungen
      2. 5.3.2 Teamstruktur
      3. 5.3.3 Sicherheitsaspekte
      4. 5.3.4 Technologie
    4. 5.4 Verwickelte Abhängigkeiten
    5. 5.5 Die Datenbank​
    6. 5.6 Dem Problem zu Leibe rücken
    7. 5.7 Beispiel: Auflösen von Fremdschlüssel-Relationen
    8. 5.8 Beispiel: Statische Daten gemeinsam nutzen
    9. 5.9 Beispiel: Veränderliche Daten gemeinsam nutzen
    10. 5.10 Beispiel: Tabellen gemeinsam nutzen​
    11. 5.11 Refactoring von Datenbanken
      1. 5.11.1 Die Aufspaltung umsetzen
    12. 5.12 Abgrenzung von Transaktionen
      1. 5.12.1 Versuchen Sie es später noch mal
      2. 5.12.2 Abbruch des gesamten Vorgangs
      3. 5.12.3 Verteilte Transaktionen​
      4. 5.12.4 Was also tun?
    13. 5.13 Berichte
    14. 5.14 Datenbanken zur Berichterstellung
    15. 5.15 Datenabruf über Serviceaufrufe
    16. 5.16 Datenpumpen​
      1. 5.16.1 Alternative Ziele
    17. 5.17 Ereignis-Datenpumpen​
    18. 5.18 Backup-Datenpumpe​
    19. 5.19 Benachrichtigung in Echtzeit
    20. 5.20 Änderungen verursachen Aufwand
    21. 5.21 Erkennen der eigentlichen Ursachen
    22. 5.22 Fazit
  9. Kapitel 6: Deployment
    1. 6.1 Continuous Integration für Einsteiger
      1. 6.1.1 Machen Sie es auch richtig?
    2. 6.2 Continuous Integration und Microservices
    3. 6.3 Build Pipelines und Continuous Delivery​
      1. 6.3.1 Die unvermeidlichen Ausnahmen
    4. 6.4 Plattformspezifische Artefakte
    5. 6.5 Betriebssystemspezifische Artefakte
    6. 6.6 Selbsterstellte Images​
      1. 6.6.1 Images als Artefakte​
      2. 6.6.2 Unveränderliche Server​
    7. 6.7 Umgebungen
      1. 6.7.1 Servicekonfiguration​
      2. 6.7.2 Zuordnung der Services zu den Hosts
      3. 6.7.3 Mehrere Services pro Host
      4. 6.7.4 Anwendungscontainer​
      5. 6.7.5 Ein Service pro Host
      6. 6.7.6 Platform-as-a-Service (PaaS)
    8. 6.8 Automatisierung​
      1. 6.8.1 Zwei Fallstudien zur Leistungsfähigkeit der Automatisierung
    9. 6.9 Physisch wird virtuell
      1. 6.9.1 Herkömmliche Virtualisierung
      2. 6.9.2 Vagrant​
      3. 6.9.3 Linux-Container​
      4. 6.9.4 Docker​
    10. 6.10 Schnittstelle für das Deployment
      1. 6.10.1 Definition der Umgebung
    11. 6.11 Fazit
  10. Kapitel 7: Testen
    1. 7.1 Testtypen
    2. 7.2 Testumfang​
      1. 7.2.1 Unit-Tests​
      2. 7.2.2 Servicetests​
      3. 7.2.3 End-to-End-Tests
      4. 7.2.4 Nachteile
      5. 7.2.5 Wie viele Tests?
    3. 7.3 Implementierung von Servicetests​
      1. 7.3.1 Mock-Objekte kontra Platzhalter
      2. 7.3.2 Ein intelligenterer Platzhalterservice
    4. 7.4 Knifflige End-to-End-Tests​
    5. 7.5 Nachteile von End-to-End-Tests
      1. 7.5.1 Unzuverlässige und fragile Tests
      2. 7.5.2 Wer programmiert die Tests?
      3. 7.5.3 Testdauer​
      4. 7.5.4 Das große Auftürmen
      5. 7.5.5 Die Metaversion
    6. 7.6 Abläufe testen, nicht Funktionalitäten
    7. 7.7 Abhilfe durch Consumer-Driven Tests
      1. 7.7.1 Pact
      2. 7.7.2 Konversationen
    8. 7.8 End-to-End-Tests: Pro und Kontra
    9. 7.9 Testen nach der Veröffentlichung​
      1. 7.9.1 Deployment und Veröffentlichung trennen
      2. 7.9.2 Canary-Veröffentlichung
      3. 7.9.3 MTTR kontra MTBR
    10. 7.10 Funktionsübergreifende Tests​
      1. 7.10.1 Geschwindigkeitstests
    11. 7.11 Fazit
  11. Kapitel 8: Monitoring
    1. 8.1 Ein Service, ein Server
    2. 8.2 Ein Service, mehrere Server
    3. 8.3 Mehrere Services, mehrere Server
    4. 8.4 Protokolle, Protokolle und noch mehr Protokolle
    5. 8.5 Kennzahlen mehrerer Services
    6. 8.6 Servicekennzahlen
    7. 8.7 Monitoringung von Pseudo-Ereignissen​
      1. 8.7.1 Implementierung des semantischen Monitorings
    8. 8.8 Korrelations-IDs​
    9. 8.9 Die Aufrufkette​
    10. 8.10 Standardisierung
    11. 8.11 Zielgruppen
    12. 8.12 Wie geht es weiter?
    13. 8.13 Fazit
  12. Kapitel 9: Sicherheit
    1. 9.1 Authentifizierung und Autorisierung​​
      1. 9.1.1 Gängige Single-Sign-On-Implementierungen​​
      2. 9.1.2 Single-Sign-On-Gateway​
      3. 9.1.3 Fein unterteilte Authentifizierung​
    2. 9.2 Authentifizierung und Autorisierung von Services​​
      1. 9.2.1 Im internen Netzwerk ist alles erlaubt
      2. 9.2.2 Authentifizierung über HTTP(S)​
      3. 9.2.3 Verwendung von SAML oder OpenID Connect
      4. 9.2.4 Client-Zertifikate​
      5. 9.2.5 HMAC über HTTP
      6. 9.2.6 API-Schlüssel​
      7. 9.2.7 Das Stellvertreterproblem​
    3. 9.3 Schutz ruhender Daten​
      1. 9.3.1 Wohlbekannte Verfahren einsetzen
      2. 9.3.2 Die Bedeutung der Schlüssel
      3. 9.3.3 Was soll verschlüsselt werden?
      4. 9.3.4 Entschlüsselung bei Bedarf
      5. 9.3.5 Backups verschlüsseln
    4. 9.4 Gestaffelte Sicherheitsstrategie
      1. 9.4.1 Firewalls​
      2. 9.4.2 Protokollierung​
      3. 9.4.3 Intrusion-Detection-Systeme
      4. 9.4.4 Unterteilung des Netzwerks​
      5. 9.4.5 Betriebssystem​
    5. 9.5 Ein ausgearbeitetes Beispiel
    6. 9.6 Datensparsamkeit
    7. 9.7 Der Faktor Mensch
    8. 9.8 Eine Goldene Regel
    9. 9.9 Integrierte Sicherheit
    10. 9.10 Externe Prüfung​
    11. 9.11 Fazit
  13. Kapitel 10: Conways Gesetz und Systemdesign
    1. 10.1 Beweise
      1. 10.1.1 Lose und eng gekoppelte Organisationen
      2. 10.1.2 Windows Vista
    2. 10.2 Netflix und Amazon
    3. 10.3 Was kann man damit anfangen?
    4. 10.4 Anpassung an Kommunikationswege
    5. 10.5 Verantwortlichkeit für Services
    6. 10.6 Gemeinschaftliche Verantwortlichkeit für Services
      1. 10.6.1 Schwierige Aufspaltung
      2. 10.6.2 Feature-Teams
      3. 10.6.3 Engpässe bei der Auslieferung
    7. 10.7 Interner Open-Source-Code
      1. 10.7.1 Aufgaben der Koordinatoren
      2. 10.7.2 Ausgereifte Services​
      3. 10.7.3 Werkzeugsammlungen​
    8. 10.8 Begrenzte Kontexte und Teamstrukturen
    9. 10.9 Verwaiste Services?
    10. 10.10 Fallstudie: RealEstate.com.au
    11. 10.11 Conways Gesetz auf den Kopf gestellt
    12. 10.12 Menschen​
    13. 10.13 Fazit
  14. Kapitel 11: Microservices skalieren
    1. 11.1 Ausfälle gibt es immer
    2. 11.2 Wie viel ist zu viel?
    3. 11.3 Schrittweiser Abbau der Funktionalität
    4. 11.4 Architektonische Sicherheitsmaßnahmen
    5. 11.5 Die antifragile Organisation
      1. 11.5.1 Timeouts​
      2. 11.5.2 Circuit Breaker​
      3. 11.5.3 Das Bulkhead-Pattern
      4. 11.5.4 Isolierung​​
    6. 11.6 Idempotenz​
    7. 11.7 Skalierung​
      1. 11.7.1 Mehr Leistung
      2. 11.7.2 Arbeitslast aufteilen​
      3. 11.7.3 Risikoverteilung​
      4. 11.7.4 Lastverteilung​
      5. 11.7.5 Worker-Systeme
      6. 11.7.6 Neuanfang
    8. 11.8 Datenbanken skalieren​
      1. 11.8.1 Verfügbarkeit des Services kontra Lebensdauer der Daten
      2. 11.8.2 Skalierung bei Lesevorgängen​
      3. 11.8.3 Skalierung bei Schreibvorgängen​
      4. 11.8.4 Gemeinsam genutzte Datenbankinfrastruktur
      5. 11.8.5 CQRS
    9. 11.9 Caching
      1. 11.9.1 Clientseitiges Caching, Proxy und serverseitiges Caching
      2. 11.9.2 Caching und HTTP
      3. 11.9.3 Caching bei Schreibvorgängen
      4. 11.9.4 Caching zur Erhöhung der Belastbarkeit
      5. 11.9.5 Den Ursprung verbergen
      6. 11.9.6 Möglichst einfach
      7. 11.9.7 Cache Poisoning: Ein warnendes Beispiel​
    10. 11.10 Automatische Skalierung​
    11. 11.11 Das CAP-Theorem
      1. 11.11.1 Aufgabe der Konsistenz​
      2. 11.11.2 Aufgabe der Verfügbarkeit​
      3. 11.11.3 Aufgabe der Partitionstoleranz?​
      4. 11.11.4 AP oder CP?
      5. 11.11.5 Keine Frage eines Entweder-Oders
      6. 11.11.6 Abbildung der Wirklichkeit
    12. 11.12 Serviceerkennung
      1. 11.12.1 DNS
    13. 11.13 Dynamische Registrierung von Services​
      1. 11.13.1 Zookeeper
      2. 11.13.2 Consul
      3. 11.13.3 Eureka
      4. 11.13.4 Eigene Serviceregistrierung
      5. 11.13.5 Menschliches Interesse
    14. 11.14 Services dokumentieren
      1. 11.14.1 Swagger​
      2. 11.14.2 HAL und der HAL-Browser
    15. 11.15 Ein sich selbst beschreibendes System
    16. 11.16 Fazit
  15. Kapitel 12: Auf den Punkt gebracht
    1. 12.1 Prinzipien​
      1. 12.1.1 Geschäftsvorgänge modellieren
      2. 12.1.2 Automatisierung kultivieren
      3. 12.1.3 Implementierungsdetails verbergen
      4. 12.1.4 Dezentralisierung​
      5. 12.1.5 Unabhängiges Deployment​​
      6. 12.1.6 Ausfälle eingrenzen​
      7. 12.1.7 Umfassendes Monitoring​
    2. 12.2 Wann sollte man auf Microservices verzichten?​
    3. 12.3 Schlusswort