Cloud-native Entwicklung mit Java

Seminarziel

Am Ende des Seminars sind die Teilnehmenden in der Lage, Cloud-native Anwendungen mit Java zu entwerfen, zu entwickeln und bereitzustellen. Sie verstehen die Prinzipien der Microservices-Architektur, können Anwendungen containerisieren und in Kubernetes deployen. Darüber hinaus sind sie mit modernen Tools und Frameworks vertraut, um skalierbare und resiliente Anwendungen zu erstellen, die den Anforderungen moderner Cloud-Umgebungen gerecht werden.

Inhalt

• Einführung in Cloud-native Entwicklung mit Java
  • Grundlagen der Cloud-nativen Entwicklung: Prinzipien wie Microservices, Containerisierung, Continuous Delivery und skalierbare Architekturen.
  • Java in der Cloud: Warum Java eine beliebte Sprache für die Entwicklung Cloud-nativer Anwendungen ist.
  • Technologien und Tools: Überblick über Spring Boot, Quarkus, Micronaut und Jakarta EE für die Entwicklung Cloud-nativer Anwendungen.
  • Vorteile für Unternehmen: Schnelle Bereitstellung, Skalierbarkeit, Ressourceneffizienz und verbesserte Zusammenarbeit in agilen Teams.
• Vergleich mit ähnlichen Systemen
  • Spring Boot vs. Quarkus: Unterschiede in Performance, Speicherverbrauch und Entwicklungserfahrung.
  • Micronaut vs. Jakarta EE: Vergleich von Funktionalität, Community-Support und Einsatzgebieten.
  • Cloud-native Java vs. andere Sprachen (Node.js, Python): Stärken von Java in Bezug auf Ökosystem, Skalierbarkeit und Tooling.
  • Einsatzszenarien: Wann welche Technologien für verschiedene Unternehmensanforderungen sinnvoll sind.
• Grundlagen der Cloud-nativen Entwicklung mit Java
  • Erstellen von Microservices: Aufbau von unabhängigen, leicht skalierbaren Microservices mit Spring Boot.
  • Containerisierung: Einführung in die Nutzung von Docker zur Bereitstellung und Verwaltung von Anwendungen.
  • Cloud-native Patterns: Nutzung von Mustern wie Service Discovery, Circuit Breaker und API-Gateway.
  • Integration mit Cloud-Services: Verbindung von Java-Anwendungen mit Diensten wie AWS, Azure und Google Cloud.
• Praxisübung 1: Erstellen eines Microservices
  • Ziel der Übung: Die Teilnehmenden entwickeln einen Microservice mit Java und Spring Boot.
  • Projektbeschreibung: Erstellung eines RESTful Microservices mit Anbindung an eine Datenbank.
  • Tools: Spring Boot, Docker, PostgreSQL.
  • Ergebnisse: Die Teilnehmenden entwickeln einen vollständig funktionsfähigen, containerisierten Microservice.
• Erweiterte Cloud-native Entwicklung mit Java
  • Event-Driven Architectures: Nutzung von Messaging-Systemen wie Apache Kafka oder RabbitMQ für ereignisgesteuerte Kommunikation zwischen Microservices.
  • Container-Orchestrierung: Einführung in Kubernetes zur Verwaltung und Skalierung von containerisierten Anwendungen.
  • Sicherheitsaspekte: Implementierung von Sicherheitsmechanismen wie OAuth 2.0, JWT und TLS in Cloud-Anwendungen.
  • Monitoring und Logging: Nutzung von Tools wie Prometheus, Grafana und ELK Stack für die Überwachung und Fehlersuche.
• Praxisübung 2: Deployment und Skalierung in Kubernetes
  • Ziel der Übung: Die Teilnehmenden deployen den zuvor erstellten Microservice auf einem Kubernetes-Cluster und skalieren ihn.
  • Projektbeschreibung: Einrichtung eines lokalen Kubernetes-Clusters mit Minikube oder k3s und Deployment des Microservices mit Kubernetes-Manifests.
  • Tools: Kubernetes, kubectl, Docker, Minikube/k3s.
  • Ergebnisse: Die Teilnehmenden verstehen den Prozess des Deployments und der Skalierung von Anwendungen in Kubernetes.
• Best Practices und Architekturdesign
  • Cloud-native Design Patterns: Anwendung von Mustern wie Circuit Breaker, Bulkhead und Retry-Mechanismen.
  • Konfigurationsmanagement: Nutzung von Tools wie Spring Cloud Config oder Kubernetes ConfigMaps.
  • Continuous Integration/Continuous Deployment (CI/CD): Einführung in automatisierte Build- und Deployment-Pipelines mit Jenkins oder GitLab CI/CD.
  • Fehlertoleranz und Resilienz: Strategien zur Erhöhung der Verfügbarkeit und Robustheit von Anwendungen.
• Zukunftsperspektiven und Trends
  • Serverless Computing: Einführung in Functions-as-a-Service (FaaS) mit AWS Lambda oder Azure Functions.
  • Service Meshes: Nutzung von Istio oder Linkerd zur Verwaltung des Service-to-Service-Verkehrs.
  • Reactive Programming: Einsatz von Frameworks wie Project Reactor oder Akka für reaktive Anwendungen.
  • Quarkus und GraalVM: Vorteile von superschnellen Java-Anwendungen mit minimalem Speicherverbrauch.
• Zusammenfassung und Handlungsempfehlungen
  • Best Practices: Tipps zur effizienten Entwicklung und Bereitstellung von Cloud-nativen Java-Anwendungen.
  • Schlüsselerkenntnisse: Wichtige Aspekte der Cloud-nativen Architektur und deren Umsetzung.
  • Nächste Schritte: Empfehlungen für weiterführende Ressourcen und Vertiefungsmöglichkeiten.