Edocti
Fortgeschrittene technische Ausbildung für den modernen Softwareingenieur
Edocti Training

Microservices in der Praxis mit Python, Flask & Consul

Mittelstufe
21 h
4.9 (609 Bewertungen)

Geplante Sessions

Aktuell sind keine Termine verfügbar.
Microservices in der Praxis mit Python, Flask & Consul

Hands-on Microservices: Entwerfen, bauen und betreiben Sie ein robustes Microservices-System mit Python, Flask und Consul.

Implementieren Sie essenzielle Pattern wie Service Discovery, Konfigurationsmanagement, Load Balancing und Observability.

Lernen Sie, sichere Kommunikation zu gewährleisten, Zustände zu verwalten und Services in realistischen Szenarien effektiv zu skalieren.

Praktische Erfahrung sammeln: Der Kurs besteht zu 70% aus intensiven Coding-Labs, die auf Docker und Cloud-ready Setups basieren.

Nutzen: Verstehen Sie die architektonischen Trade-offs und betrieblichen Herausforderungen echter Microservice-Umgebungen.

Für wen: Entwickler mit Python-Grundkenntnissen, die praxisnahe Fähigkeiten im Bereich Microservices aufbauen wollen.

Der Kurs wird durch ein umfassendes End-to-End-Projekt abgerundet, um das Gelernte zu festigen.

Fähigkeiten, die Sie lernen werden

Python & Flask Docker Container Consul & Service Discovery ELK Stack & Grafana Microservice-Architektur Observability & Metriken Load Balancing State Management

Curriculum

Tag 1 — Architektur & Service Design

  • Microservices vs Monoliths: Kosten/Nutzen, wann splitten, organisatorische Passung
  • Domain‑Driven Design (DDD): Bounded Contexts, Ubiquitous Language, Aggregates, Anti‑corruption Layer
  • Service‑Zerlegung: Data Ownership, Database‑per‑Service, transaktionale Grenzen
  • Konsistenz: Idempotency, Retries, Eventual Consistency, SAGA (Orchestration vs Choreography) — Überblick
  • Schnittstellen: REST vs gRPC (Read‑only Intro), API‑Versionierung, Fehlermodelle
  • Cross‑cutting: 12‑Factor App, Konfiguration, Secrets, Health/Readiness Checks
  • Discovery: Service Registry & Discovery mit Consul; Health Checks und Tags
  • Lab 1: Domänenmodellierung und Aufteilung in Services (catalog, orders, payments). APIs und Events skizzieren

Tag 1 — Containerisierung des Skeletons

  • Dockerfiles für Python: Multi‑Stage Builds, schlanke Images, Non‑Root‑User
  • Docker‑Compose‑Projektlayout; Umgebungen trennen (dev/test)
  • Lab 2: catalog & orders containerisieren, /health und /ready exponieren

Tag 2 — Implementierung in Python/Flask mit DI

  • Flask‑Patterns: App Factory, Blueprints, Request Lifecycle, Config (Env & Files)
  • Dependency Injection (leichtgewichtige Patterns oder dependency‑injector); Repositories, Gateways, Service Layer
  • Validierung & Serialisierung mit Pydantic/Marshmallow; Fehler auf HTTP abbilden
  • Resilienz: Timeouts, Retries (tenacity), Backoff & Jitter; Idempotency Keys
  • Service Discovery in der Praxis: Consul Agent, Service Registration, DNS vs HTTP API Lookups
  • Lab 3: Services über Consul verbinden; orders→payments mit Idempotency implementieren

Tag 2 — Observability‑Grundlagen

  • Strukturiertes Logging: JSON, Correlation IDs (X‑Request‑ID), Log‑Levels
  • Logs zu ELK schicken: Logstash Pipeline; Indizes & Retention in Elasticsearch; Dashboards in Kibana
  • Metriken: prometheus_client, RED/SUSE‑Metriken, Prozessmetriken
  • Lab 4: JSON‑Logs und /metrics aktivieren; Rate & Latenz visualisieren

Tag 3 — Full‑Stack Ops: ELK, Prometheus & Grafana

  • Compose‑Stack: Consul Server + Agents, Services, Logstash, Elasticsearch, Kibana, Prometheus, Grafana
  • Dashboards & Alerts: Grafana‑Panels für p50/p95‑Latenz, Fehlerquote; grundlegende Alarmregeln (Konzepte)
  • Security‑Aspekte: Secrets in Env/Consul KV, JWT am Edge (Skizze), TLS‑Termination (Reverse Proxy optional)
  • Lab 5: End‑to‑End Lauf — Stack starten, Last erzeugen, in Kibana und Grafana analysieren

Tag 3 — Hardening & Delivery

  • Tests: Unit/Integration, Contract Testing (Pact — Überblick)
  • Packaging & CI: pyproject.toml, Wheels, Image‑Scan; GitHub‑Actions‑Skeleton
  • Operations‑Checklisten: Readiness Probes, SLO‑Basics, Rollbacks
  • Lab 6: fehlschlagende Abhängigkeit einbauen, beobachten, sicher zurückrollen

Optionale Module

Optional — Erweiterte Patterns

  • Event‑driven Microservices mit Kafka/RabbitMQ (Überblick)
  • CQRS & SAGA Deep Dive; Outbox/Inbox Patterns
  • Service Mesh/Consul Connect und mTLS (Intro)

Kursablauf

  • Part 1: 09:00–10:30
  • Break: 10:30–10:45
  • Part 2: 10:45–12:15
  • Lunch break: 12:15–13:15
  • Part 3: 13:15–15:15
  • Break: 15:15–15:30
  • Part 4: 15:30–17:30

Haben Sie an diesem Kurs teilgenommen?

Ihre Meinung ist uns sehr wichtig. Teilen Sie Ihre Erfahrungen mit uns und helfen Sie uns, diesen Kurs für zukünftige Teilnehmer weiter zu verbessern.

Feedback teilen

Möchten Sie mehr erfahren? Wir helfen Ihnen gern!

Oder schreiben Sie uns direkt an training@edocti.com.