Microservices Tutorial - Mit Docker und Spring arbeiten

Microservices mit Spring Boot, Spring Cloud und Docker

In diesem Tutorial wird man auf den Umgang mit Microservices vorbereitet. Eberhard Wolff erklärt zunächst, was Microservices eigentlich sind und mit welchen Chancen und Herausforderungen die Arbeit mit ihnen verbunden ist. Nachdem die Grundlagen etabliert wurden, erklärt er den Umgang mit der Container-Sofware Docker und den Umgang mit dem Spring Framework, die anhand eines Micoservices-Beispiels in der letzten Lektion noch einmal praktisch angewendet werden.

Lernziele

Das Ziel dieses Tutorials ist es, die komplexe Welt der Microservices verständlich zu machen und zu erklären, wie das Arbeiten mit Microservices in Docker, Spring Boot und Spring Cloud funktioniert.

Einführung
Gratis ansehen15 Minuten
- Einleitung
  
  00:12
- Definition von Microservices
  
  03:20
- Komponenten kollaborieren
  
  02:51
- Layered Microservices
  
  04:41
- Herausforderungen bei Layered Microservices
  
  03:57
- Self-Contained Systems
  
  05:10
- Vorteile von Self-Contained Systems
  
  01:00
- Microservices vs. Serviceorientierte Architektur
  
  03:18
- Beispiel: Microservices im Onlineshop
  
  01:23
Was sind Microservices?
- Einleitung
  
  00:41
- Größe von Microservices
  
  00:46
- Microservices sollten klein sein
  
  03:33
- Microservices sollten groß sein
  
  05:18
- Conway's Law
  
  07:45
- Software agil skalieren
  
  02:11
- Domain Driven Design
  
  02:47
- Microservices und Bounded Context
  
  02:39
- Context Relationships
  
  03:19
- Genaue Definition von Microservices
  
  01:12
Warum Microservices?
- Einleitung
  
  00:18
- Agiles Arbeiten mit Microservices
  
  00:51
- Technologiefreiheit von Microservices
  
  01:46
- Robustheit von Microservices
  
  01:37
- Unabhängige Skalierbarkeit von Microservices
  
  00:43
- Legacy-Anwendungen mit Microservices
  
  03:20
- Nachhaltige Entwicklung mit Microservices
  
  03:36
- Continuous Delivery
  
  07:05
- Zusammenfassung: Warum Microservices?
  
  03:47
Herausforderungen
- Einleitung
  
  00:17
- Deployment und Betrieb
  
  04:43
- Verteiltes System
  
  05:00
- Code-Wiederverwendung
  
  03:45
- Funktionale Architektur
  
  00:50
- Refactoring
  
  02:42
- Spannungsverhältnis auflösen
  
  01:16
- Management der Abhängigkeiten
  
  04:28
- Globale Architektur
  
  03:34
- Zusammenfassung
  
  03:21
Docker
- Einführung
  
  00:25
- Docker Container
  
  05:08
- Docker Machine
  
  02:29
- Startbedingungen für die Programmierdemo
  
  01:14
- Demo: 50 Container starten
  
  09:16
- Einen Docker Container erstellen
  
  04:42
- Arbeiten mit Images
  
  01:07
- Demo: Docker Images
  
  10:05
- Kommandos in Docker
  
  02:06
- Kommunikation zwischen Docker Containern
  
  00:26
- Docker in Clustern skalieren
  
  03:45
- Docker Compose
  
  02:27
- Zusammenfassung
  
  01:25
Spring Boot
- Einführung
  
  00:20
- Voraussetzungen für eine Microservices-Infrastruktur
  
  01:22
- Demo: Wie setze ich eine Microservices-Infrastruktur auf?
  
  07:51
- Eigenschaften eines Microservices Framework in Spring Boot
  
  05:41
- Deployment mit Spring Boot
  
  01:03
- Demo: Deployment
  
  05:25
- Überblick über den Deployment-Ablauf
  
  01:17
- Spring Boot Actuator
  
  02:30
- Demo: Metrics
  
  09:29
- CRaSH Shell
  
  00:49
- Demo: Spring-Boot-Anwendungen mit CRaSH managen
  
  04:45
- Basis für Microservices-Systeme
  
  01:48
- Weiterführende Links und Zusammenfassung
  
  00:57
Ein Microservices-Beispiel mit Spring Cloud
- Einleitung
  
  00:50
- Aufbau des Beispiels
  
  00:33
- Stubs für unabhängige Entwicklung
  
  00:55
- Demo: Stubs
  
  05:10
- Consumer-driven Contract Tests
  
  01:43
- Verifizierung mit Pact
  
  01:46
- Demo: Consumer-driven Contract Tests
  
  09:04
- Pact als Alternative
  
  02:39
- Architektur und Bounded Context
  
  07:44
- Spring Cloud als Technologie
  
  06:07
- Überblick über die Demo
  
  01:28
- Service Discovery mit Eureka
  
  01:32
- Warum Eureka?
  
  03:05
- Eureka Client
  
  02:51
- Eureka Server
  
  02:07
- Consul als Alternative
  
  03:38
- Load Balancing mit Ribbon
  
  04:22
- Demo: Load Balancing mit Ribbon
  
  08:02
- Alternative: Externe Load Balancer
  
  02:10
- Fehlerszenarien
  
  02:01
- Hystrix
  
  02:53
- Hystrix-Konfiguration
  
  01:19
- Integration von Hystrix in Spring Cloud
  
  01:51
- Verbesserungspotenzial
  
  00:56
- Hystrix Dashboard
  
  00:19
- Demo: Hystrix
  
  07:48
- Turbine
  
  00:49
- Routing mit Zuul
  
  02:49
- Alternativen
  
  01:37
- Einleitung Demo
  
  00:42
- Demo: ESI
  
  03:44
- Erläuterung zur Demo
  
  00:56
- Demo: ESI
  
  05:16
- Beispiel für Frontend-Integration
  
  05:08
- Zusammenfassung der Demo
  
  01:57
- Weitere Spring-Cloud-Technologien
  
  03:38
- Verbesserungspotential
  
  00:45
- Log-Analyse
  
  00:40
- Monitoring
  
  00:14
- Zusammenfassung
  
  01:43

PRÄSENTIERT VON

Eberhard Wolff

Keine technischen Voraussetzungen.

Microservices

mit Spring Boot, Spring Cloud und Docker

Microservices mit Spring Boot, Spring Cloud und Docker

Lernziele

keyboard_arrow_rightEinführung

Einleitung 00:12

Definition von Microservices 03:20

Komponenten kollaborieren 02:51

Layered Microservices 04:41

Herausforderungen bei Layered Microservices 03:57

Self-Contained Systems 05:10

Vorteile von Self-Contained Systems 01:00

Microservices vs. Serviceorientierte Architektur 03:18

Beispiel: Microservices im Onlineshop 01:23

keyboard_arrow_rightWas sind Microservices?

Einleitung 00:41

Größe von Microservices 00:46

Microservices sollten klein sein 03:33

Microservices sollten groß sein 05:18

Conway's Law 07:45

Software agil skalieren 02:11

Domain Driven Design 02:47

Microservices und Bounded Context 02:39

Context Relationships 03:19

Genaue Definition von Microservices 01:12

keyboard_arrow_rightWarum Microservices?

Einleitung 00:18

Agiles Arbeiten mit Microservices 00:51

Technologiefreiheit von Microservices 01:46

Robustheit von Microservices 01:37

Unabhängige Skalierbarkeit von Microservices 00:43

Legacy-Anwendungen mit Microservices 03:20

Nachhaltige Entwicklung mit Microservices 03:36

Continuous Delivery 07:05

Zusammenfassung: Warum Microservices? 03:47

keyboard_arrow_rightHerausforderungen

Einleitung 00:17

Deployment und Betrieb 04:43

Verteiltes System 05:00

Code-Wiederverwendung 03:45

Funktionale Architektur 00:50

Refactoring 02:42

Spannungsverhältnis auflösen 01:16

Management der Abhängigkeiten 04:28

Globale Architektur 03:34

Zusammenfassung 03:21

keyboard_arrow_rightDocker

Einführung 00:25

Docker Container 05:08

Docker Machine 02:29

Startbedingungen für die Programmierdemo 01:14

Demo: 50 Container starten 09:16

Einen Docker Container erstellen 04:42

Arbeiten mit Images 01:07

Demo: Docker Images 10:05

Kommandos in Docker 02:06

Kommunikation zwischen Docker Containern 00:26

Docker in Clustern skalieren 03:45

Docker Compose 02:27

Zusammenfassung 01:25

keyboard_arrow_rightSpring Boot

Einführung 00:20

Voraussetzungen für eine Microservices-Infrastruktur 01:22

Demo: Wie setze ich eine Microservices-Infrastruktur auf? 07:51

Eigenschaften eines Microservices Framework in Spring Boot 05:41

Deployment mit Spring Boot 01:03

Demo: Deployment 05:25

Überblick über den Deployment-Ablauf 01:17

Spring Boot Actuator 02:30

Demo: Metrics 09:29

CRaSH Shell 00:49

Demo: Spring-Boot-Anwendungen mit CRaSH managen 04:45

Basis für Microservices-Systeme 01:48

Weiterführende Links und Zusammenfassung 00:57

keyboard_arrow_rightEin Microservices-Beispiel mit Spring Cloud

Einleitung 00:50

Aufbau des Beispiels 00:33

Stubs für unabhängige Entwicklung 00:55

Demo: Stubs 05:10

Consumer-driven Contract Tests 01:43

Einführung

Einleitung

00:12

Definition von Microservices

03:20

Komponenten kollaborieren

02:51

Layered Microservices

04:41

Herausforderungen bei Layered Microservices

03:57

Self-Contained Systems

05:10

Vorteile von Self-Contained Systems

01:00

Microservices vs. Serviceorientierte Architektur

03:18

Beispiel: Microservices im Onlineshop

01:23

Was sind Microservices?

Einleitung

00:41

Größe von Microservices

00:46

Microservices sollten klein sein

03:33

Microservices sollten groß sein

05:18

Conway's Law

07:45

Software agil skalieren

02:11

Domain Driven Design

02:47

Microservices und Bounded Context

02:39

Context Relationships

03:19

Genaue Definition von Microservices

01:12

Warum Microservices?

Einleitung

00:18

Agiles Arbeiten mit Microservices

00:51

Technologiefreiheit von Microservices

01:46

Robustheit von Microservices

01:37

Unabhängige Skalierbarkeit von Microservices

00:43

Legacy-Anwendungen mit Microservices

03:20

Nachhaltige Entwicklung mit Microservices

03:36

Continuous Delivery

07:05

Zusammenfassung: Warum Microservices?

03:47

Herausforderungen

Einleitung

00:17

Deployment und Betrieb

04:43

Verteiltes System

05:00

Code-Wiederverwendung

03:45

Funktionale Architektur

00:50

Refactoring

02:42

Spannungsverhältnis auflösen

01:16

Management der Abhängigkeiten

04:28

Globale Architektur

03:34

Zusammenfassung

03:21

Docker

Einführung

00:25

Docker Container

05:08

Docker Machine

02:29

Startbedingungen für die Programmierdemo

01:14

Demo: 50 Container starten

09:16

Einen Docker Container erstellen

04:42

Arbeiten mit Images

01:07

Demo: Docker Images

10:05

Kommandos in Docker

02:06

Kommunikation zwischen Docker Containern

00:26

Docker in Clustern skalieren

03:45

Docker Compose

02:27

Zusammenfassung

01:25

Spring Boot

Einführung

00:20

Voraussetzungen für eine Microservices-Infrastruktur

01:22

Demo: Wie setze ich eine Microservices-Infrastruktur auf?

07:51

Eigenschaften eines Microservices Framework in Spring Boot

05:41

Deployment mit Spring Boot

01:03

Demo: Deployment

05:25

Überblick über den Deployment-Ablauf

01:17

Spring Boot Actuator

02:30

Demo: Metrics

09:29

CRaSH Shell

00:49

Demo: Spring-Boot-Anwendungen mit CRaSH managen

04:45

Basis für Microservices-Systeme

01:48

Weiterführende Links und Zusammenfassung

00:57

Ein Microservices-Beispiel mit Spring Cloud

Einleitung

00:50

Aufbau des Beispiels

00:33

Stubs für unabhängige Entwicklung

00:55

Demo: Stubs

05:10

Consumer-driven Contract Tests

01:43

Verifizierung mit Pact

01:46

Demo: Consumer-driven Contract Tests

09:04

Pact als Alternative

02:39

Architektur und Bounded Context

07:44