Software Architecture für Entwickler - Advanced: Event-Driven Architecture und Production Engineering

Kursüberblick

Dieser intensive 3-tägige Advanced-Kurs baut auf grundlegenden Software-Architektur-Kenntnissen auf und vertieft moderne Themen wie Event-Driven Architecture, Service Mesh, Observability und Performance Engineering. Lernen Sie fortgeschrittene Deployment-Strategien, Distributed Tracing, Chaos Engineering und wie Sie hochverfügbare, skalierbare Systeme in Production betreiben.

Was Sie lernen werden

Tag 1: Advanced Deployment & Service Mesh

Advanced Deployment Strategies
- Blue/Green Deployments
- Canary Releases
- Progressive Delivery (Argo Rollouts, Flagger)
- Shadow Traffic / Mirroring
- Rolling vs. Recreate (Kubernetes)
- Feature Flags (LaunchDarkly, Unleash)
Service Mesh & Advanced Traffic Management
- Istio / Linkerd Basics
- Traffic Shaping (Splitting, Mirroring)
- mTLS, Ingress/Egress, Sidecar Pattern
- Policy Enforcement & Telemetry
API Evolution & Backward Compatibility
- API Versioning Strategies (URI, Header, Media Types)
- Backward/Forward Compatibility Best Practices
- Consumer-Driven Contracts (Pact)
- Schema Registry (Avro, Protobuf)
- Rolling Updates without Breaking Clients

Tag 2: Event-Driven Architecture & Distributed Systems

Event-Driven Architecture (EDA)
- Event Brokers: Kafka, RabbitMQ, AWS SNS/SQS
- Event Streams vs. Queues
- Choreography vs. Orchestration
- Messaging Patterns: Saga Pattern, Outbox Pattern, Debezium CDC
- Event Sourcing & Idempotency
Streaming & Real-Time Processing
- Kafka Streams, ksqlDB
- Stream Partitioning & Consumer Groups
- Real-time Event Pipelines & Backpressure Handling
Data Consistency & Distributed Transactions
- Strong vs. Eventual Consistency
- CAP Theorem in Practice
- Optimistic vs. Pessimistic Concurrency
- Transactional Outbox, Change Data Capture (CDC)
- Saga Pattern Deep Dive (Orchestration vs. Choreography)
- Avoiding Dual Writes & Other Anti-Patterns

Tag 3: Security, Observability & Performance Engineering

Advanced Security Concepts
- Zero Trust Architecture Deep Dive
- Service-to-Service Auth: mTLS, SPIFFE/SPIRE
- API Security Hardening (OAuth2 Scopes, WAF, OPA/Rego)
- Secrets Management (Vault, AWS KMS, K8s Secrets)
- Supply Chain Security (SLSA, SBOM, Sigstore Cosign, Image Signing)
Monitoring & Observability
- OpenTelemetry (Traces, Metrics, Logs)
- Distributed Tracing (Jaeger, Zipkin)
- Metrics & Dashboards (Prometheus, Grafana)
- Logging Pipelines (Loki, ELK/EFK)
- SRE Golden Signals & Alerting
Performance Engineering & Load Testing
- Testing Types: Load, Stress, Spike, Soak, Capacity
- Tools: k6, Locust, JMeter, Gatling
- Benchmarking Microservices (RPS, P99 Latency, Throughput)
- Bottleneck Analysis: Profiling, Flamegraphs, pprof
- Chaos Engineering (Gremlin, Chaos Mesh)
High Availability & Scalability
- Horizontal/Vertical Scaling Strategies
- K8s HPA/VPA/Cluster Autoscaler
- Multi-Region & Multi-Cluster Deployment Patterns
- Failover, Backup & Disaster Recovery Strategies

Voraussetzungen

Grundlegende Software-Architektur Kenntnisse (idealerweise Basic-Kurs absolviert)
Erfahrung mit Microservices und Container-Technologien
Praktische Kenntnisse in Kubernetes
Verständnis von REST APIs und asynchroner Kommunikation
Programmiererfahrung in mindestens einer Sprache
DevOps Grundlagen (CI/CD, Docker)

Kursformat

Dauer: 3 ganze Tage (je 8 Stunden)
Format: Instruktor-geleitetes Training mit intensiven Hands-on Labs
Klassengröße: Maximal 10 Teilnehmer für intensive Betreuung
Materialien: Advanced Architektur-Patterns, Code-Beispiele und Production Templates inklusive

Hands-on Labs und Übungen

Während des Kurses arbeiten Sie an fortgeschrittenen Projekten:

Blue/Green und Canary Deployment mit Argo Rollouts
Service Mesh Setup: Istio Installation und Traffic Management
Event-Driven System mit Kafka: Producer, Consumer, Streams
Saga Pattern Implementation: Orchestrierung vs. Choreografie
Schema Registry: Avro/Protobuf für API Evolution
Zero Trust Setup: mTLS mit SPIFFE/SPIRE
Distributed Tracing: OpenTelemetry mit Jaeger Integration
Performance Testing: k6 Load Tests und Bottleneck Analysis
Chaos Engineering: Failure Injection mit Chaos Mesh
Multi-Region Deployment: Failover-Strategien implementieren

Verwendete Tools und Technologien

Im Kurs arbeiten wir mit:

Event Streaming: Apache Kafka, Kafka Streams, ksqlDB
Service Mesh: Istio oder Linkerd
Progressive Delivery: Argo Rollouts, Flagger
Observability: OpenTelemetry, Jaeger, Prometheus, Grafana, Loki
Load Testing: k6, Locust
Security: Vault, SPIFFE/SPIRE, OPA
Chaos Engineering: Chaos Mesh, Gremlin
Feature Flags: Unleash oder LaunchDarkly
Schema Registry: Confluent Schema Registry

Wer sollte teilnehmen

Senior Software Engineers und Architects
Platform Engineers und SREs
DevOps Engineers mit Architektur-Interesse
Technical Leads für Microservices-Teams
Backend-Entwickler, die Production-Skills vertiefen möchten
Alle, die den Basic-Kurs absolviert haben und weiter lernen wollen

Lernziele

Am Ende dieses Kurses werden Sie in der Lage sein:

✅ Advanced Deployment-Strategien (Blue/Green, Canary) umzusetzen
✅ Service Meshes für Traffic Management und Security zu nutzen
✅ Event-Driven Architectures mit Kafka zu designen und implementieren
✅ Saga Pattern für verteilte Transaktionen anzuwenden
✅ API-Versionierung und Backward Compatibility zu gewährleisten
✅ Zero Trust Security in Microservices zu implementieren
✅ Distributed Tracing und Observability aufzubauen
✅ Performance Testing und Bottleneck Analysis durchzuführen
✅ Chaos Engineering für Resilience Testing einzusetzen
✅ Datenkonsistenz in verteilten Systemen zu managen
✅ Multi-Region High-Availability Systeme zu designen
✅ Production-Grade Systeme zu betreiben und zu optimieren

Kursmaterialien

Alle Teilnehmer erhalten:

Advanced Software Architecture Material
Zugang zu Advanced Lab-Umgebung (14 Tage)
Digitales Advanced Certificate
Labs und weiteres Kursmaterial
30 Tage Post-Kurs Consulting-Support