Software Architecture für Entwickler: Von Requirements bis Deployment

Kursüberblick

Dieser umfassende 3-tägige Kurs vermittelt moderne Software-Architektur von der Anforderungsanalyse bis zum produktiven Deployment. Lernen Sie Requirements Engineering, Domain-Driven Design, Microservices-Architektur und DevOps-Practices mit Kubernetes und GitOps. Ein praxisorientierter Kurs für Entwickler, die architektonische Entscheidungen verstehen und umsetzen möchten.

Was Sie lernen werden

Tag 1: Requirements Engineering und Architecture Design

• Einführung in Requirements Engineering

  • Persona-Entwicklung: Definition von Benutzerprofilen und Bedürfnissen
  • Szenario-Erstellung: Use-Case-Szenarien und szenariobasierte Anforderungen
  • User Stories und Tasks: SMART-Kriterien, Akzeptanzkriterien

• Erstellung des Context Models

  • System-Kontext: Context-Diagramm, System-Grenzen, externe Systeme
  • System-Boundaries: Identifikation von Schnittstellen und Integrationen

• Domain-Driven Design (DDD)

  • Bounded Contexts: Trennung von Domain-Modellen und Daten
  • Aggregates, Entities, Value Objects: Modellierung von Business-Objekten
  • Ubiquitous Language: Gemeinsame Sprache zwischen Domain-Experten und Entwicklern

• Microservices Architecture

  • Microservices: Aufbau unabhängiger und skalierbarer Services
  • Datenmanagement: Database Sharding, Eventual Consistency
  • Service-Kommunikation: REST (JSON), gRPC (Protobuf), API Gateways (z.B. Kong, NGINX)

• Resilience in der Architektur

  • Resilience Patterns: Circuit Breaker, Bulkhead, Retry
  • Error Handling: Graceful Degradation, Fallback-Strategien

• API Design und Inter-Service Communication

  • API Gateways: Kong, Zuul, Spring Cloud Gateway für Service-Orchestrierung
  • REST vs. gRPC: Protokoll-Auswahl, HTTP/2, JSON vs. Protobuf
  • Security Best Practices: OAuth 2.0, OpenID Connect, JWT, API Keys

Tag 2: Deployment und DevOps

• Deployment mit Docker und Best Practices

  • Containerisierung: Docker-Container, Dockerfiles, Images, Docker Compose
  • Standardisierte Deployment-Einheiten: Deployment und Versionierung mit Docker Hub

• Infrastructure Automation und Best Practices

  • IaC Tools: Terraform, AWS CloudFormation, Ansible
  • Cloud-Infrastruktur-Bereitstellung: Ressourcen-Provisionierung, State Management

• Deployment Automation

  • Continuous Integration: Jenkins, GitLab CI, CircleCI für automatisierte Builds
  • Continuous Deployment: Automatisiertes Testing (Unit, Integration, E2E), Canary Releases
  • Continuous Delivery

• GitOps

  • GitOps Tools: ArgoCD, FluxCD
  • GitOps Prinzipien: Infrastructure-as-Code mit Git als Single Source of Truth

Tag 3: Kubernetes und Production-Ready Architecture

• Execution Platform: Kubernetes

  • Kubernetes Basics: Pods, Deployments, Services, Namespaces, ConfigMaps, Secrets
  • Cluster Management: Helm (Package Manager), Kubernetes Operators
  • Scaling: Horizontal Pod Autoscaling, Cluster Autoscaler
  • Resilience und High Availability

• Service Discovery und Load Balancing

  • Service Discovery: Kubernetes DNS, Istio
  • Load Balancing: Round Robin, Least Connections, HAProxy, NGINX, Istio (Service Mesh)

• Security in Microservices Architectures

  • Zero Trust: Mutual TLS, Istio für mTLS, Service Mesh Security
  • Network Isolation
  • Secrets Management: Vault, AWS Secrets Manager, Kubernetes Secrets
  • API Security: OAuth 2.0, JWT, Rate Limiting, IP Whitelisting

• Scalability und Performance

  • Horizontal Scaling: Auto-Scaling, Kubernetes Horizontal Pod Autoscaler
  • Vertical Scaling: Resource Limits (CPU, Memory), Vertical Pod Autoscaler
  • Performance-Optimierung: Design und Durchführung eines Benchmark-Szenarios

Voraussetzungen

• Solide Programmierkenntnisse in mindestens einer Sprache
• Grundverständnis von Web-Technologien und APIs
• Erste Erfahrungen mit Docker von Vorteil
• Grundkenntnisse in Linux/Command Line
• Verständnis von Git und Versionskontrolle

Kursformat

• Dauer: 3 ganze Tage (je 8 Stunden)
• Format: Instruktor-geleitetes Training mit umfangreichen Hands-on Labs
• Klassengröße: Maximal 12 Teilnehmer für intensive Betreuung
• Materialien: Umfassende Kursunterlagen, Code-Beispiele und Deployment-Templates inklusive

Hands-on Labs und Übungen

Während des Kurses arbeiten Sie an praxisnahen Projekten:

1. Requirements Workshop: Erstellung von Personas und User Stories
2. Context Model: System-Grenzen und externe Integrationen definieren
3. DDD Modeling: Design von Bounded Contexts und Aggregates
4. Microservice Implementation: REST und gRPC Services entwickeln
5. Resilience Patterns: Circuit Breaker und Retry-Logic implementieren
6. Docker Containerization: Multi-Stage Builds und Docker Compose
7. Kubernetes Deployment: Deploy einer Microservices-Anwendung
8. GitOps Setup: ArgoCD für automatisierte Deployments konfigurieren
9. Service Mesh: Istio für mTLS und Traffic Management
10. Monitoring und Scaling: Horizontal Pod Autoscaler konfigurieren

Verwendete Tools und Technologien

Im Kurs arbeiten wir mit:

• Docker und Docker Compose
• Kubernetes (lokal mit Minikube oder Kind)
• Helm für Package Management
• ArgoCD oder FluxCD für GitOps
• Terraform für Infrastructure as Code
• Istio Service Mesh
• Prometheus und Grafana für Monitoring
• Kong oder NGINX als API Gateway
• Git und GitLab/GitHub

Wer sollte teilnehmen

• Backend-Entwickler, die Architektur verstehen möchten
• Software-Architekten (Junior bis Mid-Level)
• DevOps Engineers
• Full-Stack Entwickler
• Technical Leads und Team Leads
• Entwickler, die zu Cloud-Native wechseln möchten
• Alle, die moderne Microservices-Architekturen verstehen und bauen wollen

Lernziele

Am Ende dieses Kurses werden Sie in der Lage sein:

• ✅ Requirements professionell zu erheben und zu dokumentieren
• ✅ System-Kontexte und Boundaries zu definieren
• ✅ Domain-Driven Design Konzepte anzuwenden
• ✅ Microservices-Architekturen zu designen
• ✅ Resilience Patterns zu implementieren
• ✅ APIs sicher zu gestalten (OAuth, JWT)
• ✅ Anwendungen mit Docker zu containerisieren
• ✅ Infrastructure as Code mit Terraform zu schreiben
• ✅ CI/CD Pipelines aufzubauen
• ✅ GitOps-Workflows zu implementieren
• ✅ Kubernetes-Deployments zu orchestrieren
• ✅ Service Meshes für Security und Observability einzusetzen
• ✅ Auto-Scaling und Performance-Optimierung durchzuführen

Kursmaterialien

Alle Teilnehmer erhalten:

• Umfassendes Software Architecture Material
• Zugang zu Lab-Umgebung und Code-Repository (14 Tage)
• Digitales Abschlusszertifikat
• Labs und weiteres Kursmaterial
• 30 Tage Post-Kurs E-Mail-Support