Kontakt aufnehmen

Schulungsübersicht

Tag 1: Grundlagen der Event-getriebenen Architektur in Go

  • Einführung in EDA
    • Was ist Event-getriebene Architektur?
    • Vergleich von monolithischen, Microservice- und event-getriebenen Systemen
    • Warum das Konkurrenzmodell und die leichtgewichtigen Goroutines von Go ideal für EDA sind
  • Kernkonzepte und Vorteile
    • Entkopplung, Skalierbarkeit und Resilienz in Unternehmenssystemen
    • Definition von Events, Produzenten, Verbrauchern und Event-Brokern
    • Reale Beispiele und Fallstudien, in denen Go leistungsfähige Event-Systeme antreibt
  • CAP-Theorem und Abwägungen in EDA
    • Überblick über Konsistenz, Verfügbarkeit und Partitionstoleranz
    • Auswirkungen von EDA auf diese Eigenschaften
    • Strategien zur Ausbalancierung von Konsistenz und Verfügbarkeit in Go-basierten Systemen

Tag 2: Events, Nachrichten und Kommunikationsmuster in Go

  • Verständnis der Event-Typen
    • Domänenereignisse vs. Integrationsereignisse
    • Synchrone vs. asynchrone Events in Go-Anwendungen
  • Nachrichtenmuster in der Praxis
    • Publikation-Abonnement (Pub/Sub) in Go
    • Gestaltung und Strukturierung von Event-Payloads mit JSON, Protocol Buffers oder Avro in Go
  • Implementierung der Event-Verarbeitung in Go
    • Überblick über beliebte Go-Bibliotheken und Frameworks für Messaging
    • Code-Beispiele: Dispatchen und Verarbeiten von Events mit idiomatischen Go-Mustern
    • Praxis-Session: Aufbau eines einfachen event-getriebenen Diensts in Go

Tag 3: Nachrichtensysteme und Event-Broker mit Go

  • Auswahl und Integration von Event-Brokern
    • Überblick über beliebte Broker: Apache Kafka, RabbitMQ und NATS
    • Vergleich von Anwendungsfällen und Best Practices für Go-basierte Systeme
  • Einrichtung der Nachrichteninfrastruktur
    • Docker Compose-Setup für Kafka, RabbitMQ oder NATS
    • Konfiguration von Topics, Exchanges, Queues und Channels
    • Überblick über Go-Client-Bibliotheken
  • Praxisworkshop
    • Aufbau einer Go-Microservice-Beispielanwendung, die Events produziert und konsumiert
    • Integration des Diensts mit dem gewählten Event-Broker
    • Fehlerbehebung und Testen von Event-Flows

Tag 4: Deployment, Überwachung und fortgeschrittene Themen in Go-EDA

  • Deployment von Go-Event-Getriebenen Anwendungen auf Kubernetes
    • Containerisierung von Go-Anwendungen für den Produktivbetrieb
    • Deployment von Kafka (oder anderen Brokern) auf Kubernetes-Clustern
    • Einführung in KEDA (Kubernetes Event-Driven Autoscaling) zur Skalierung von Event-Verbrauchern
  • Fehlerbehandlung und Überwachung
    • Behandlung von Event-Fehlern mit verschiedenen Strategien
    • Implementierung von Observability in Go-Diensten
  • Fortgeschrittene Themen und Q&A
    • Untersuchung serverloser Event-getriebener Architekturen mit Go
    • Event-Choreographie vs. Orchestrierung: Anwendungsfälle und Designüberlegungen
    • Häufige Stolpersteine, gelernte Lehren und Best Practices
    • Offene Q&A-Session und interaktive Fehlerbehebung

Voraussetzungen

  • Sicherer Umgang mit Go (Golang), einschließlich der Nutzung von Goroutines und Channels
  • Grundlegendes Verständnis von Softwarearchitekturmodellen wie Monolithen und Microservices
  • Vertrautheit mit Docker und Docker Compose
  • Grundkenntnisse in REST APIs und Netzwerkgrundlagen
  • Erfahrung mit Kommandozeilentools und Git
  • Optional, aber hilfreich: Vorwissen zu Kubernetes und Nachrichtensystemen wie Kafka, RabbitMQ oder NATS

Zielgruppe

  • Go-Entwickler, die skalierbare, event-getriebene Anwendungen bauen
  • Softwareingenieure, die von monolithischen oder REST-basierten Architekturen auf asynchrone Systeme umsteigen
  • DevOps- und Cloud-Ingenieure, die mit containerisierten oder verteilten Microservices arbeiten
  • Technische Architekten und Systemdesigner, die EDA-Muster mit Go erkunden
 28 Stunden

Teilnehmerzahl


Preis je Teilnehmer (exkl. USt)

Erfahrungsberichte (7)

Kommende Kurse

Verwandte Kategorien