Microservices - Konzeption und Design

Microservices - Konzeption und Design

by Sam Newman
Released
Publisher(s): mitp Verlag
ISBN: None

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

None

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

Product information

  • Title: Microservices - Konzeption und Design
  • Author(s): Sam Newman
  • Release date:
  • Publisher(s): mitp Verlag
  • ISBN: None