Microservices Schulungen in Leipzig

Dieses von einem Trainer geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Java-Entwickler mittleren Kenntnisstands, die Apache Kafka in ihre Anwendungen integrieren möchten, um zuverlässige, skalierbare und leistungsfähige Nachrichtenübertragungssysteme zu realisieren.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein zu:

• Die Architektur sowie die Kernkomponenten von Kafka zu verstehen.
• Einen Kafka-Cluster einzurichten und zu konfigurieren.
• Mithilfe von Java Nachrichten zu produzieren und zu konsumieren.
• Kafka Streams zur Verarbeitung von Echtzeitdaten einzusetzen.
• Für Ausfallsicherheit sowie Skalierbarkeit in Kafka-Anwendungen zu sorgen.

Dieses praxisorientierte Live-Training unter Leitung eines Trainers in Leipzig (online oder vor Ort) richtet sich an Entwickler mittleren bis fortgeschrittenen Niveaus sowie DevOps-Profis und Architekten, die lernen möchten, widerstandsfähige Anwendungen mit Microservices, Containern sowie automatisierten CI/CD-Pipelines zu entwerfen, bereitzustellen und zu verwalten.

Am Ende des Kurses werden die Teilnehmer in der Lage sein:

• Die Grundlagen und Umsetzung einer Microservices-Architektur zu verstehen.
• Containerisierte Anwendungen mittels Docker und Kubernetes einzusetzen und zu verwalten.
• CI/CD-Pipelines für automatisierte Bereitstellungen einzurichten und zu optimieren.
• Beste Praktiken im Bereich Sicherheit, Überwachung und Observability anzuwenden.

Dieses von Instruktoren geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Plattformentwickler auf fortgeschrittenem Niveau sowie DevOps-Profis, die lernen möchten, Anwendungen mithilfe von Microservices und Kubernetes zu skalieren.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein zu:

• Skalierbare Microservices-Architekturen zu entwerfen und umzusetzen.
• Anwendungen auf Kubernetes-Clustern bereitzustellen und zu verwalten.
• Helm-Charts zur effizienten Bereitstellung von Diensten zu nutzen.
• Die Funktionsfähigkeit von Microservices in der Produktivumgebung zu überwachen und aufrechtzuerhalten.
• Beste Praktiken im Bereich Sicherheit und Compliance innerhalb einer Kubernetes-Umgebung anzuwenden.

Dieses von einem Trainer geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Java-Entwickler mittleren Kenntnisstands, die lernen möchten, Mikrodienst-basierte Anwendungen mit Frameworks wie Spring Boot und Spring Cloud zu entwerfen, zu programmieren, bereitzustellen und zu warten.

Am Ende dieses Trainings werden die Teilnehmer folgendes können:

• Die Grundprinzipien sowie Vorteile der Mikrodienst-Architektur verstehen.
• Mikrodienste mithilfe von Java und Spring Boot erstellen sowie bereitstellen.
• Dienstfindung, Konfigurationsverwaltung sowie API-Gateways implementieren.
• Mikrodienste sicher, überwachen und effizient skalieren.
• Mikrodienste mit Docker und Kubernetes einführen.

Dieses von einem Trainer geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an erfahrene Entwickler, die lernen möchten, Anwendungen mithilfe von Microservices zu entwickeln, bereitzustellen und zu skalieren – alles basierend auf NodeJS und React.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein:

• Anwendungen mit verschiedenen Microservices zu entwickeln, einzusetzen und zu skalieren.
• Eine serverseitig gerenderte React-Anwendung zu erstellen.
• Mehr-Service-Anwendungen mithilfe von Docker und Kubernetes in die Cloud zu deployen.
• Tests an Microservices durchzuführen.

Dieses vom Dozenten geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Entwickler, Integrationsarchitekten sowie Systemadministratoren, die die fortgeschrittenen Integrationsmuster und -techniken mit Apache Camel beherrschen möchten.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein zu:

• Fortgeschrittene Integrationsmuster sowie Techniken zu verstehen.
• Komplexe Routing- und Transformationsprozesse zu implementieren.
• Performance und Skalierbarkeit zu optimieren.
• Fehler und Ausnahmen in komplexen Integrationsszenarien zu behandeln.
• Apache Camel mit verschiedenen Technologien und Plattformen zu integrieren.

Dieses praxisorientierte Training unter Anleitung eines Instruktors in Leipzig (online oder vor Ort) richtet sich an Entwickler mittleren Niveaus, die große Datenanwendungen mit Apache Kafka entwickeln möchten.

Am Ende dieses Kurses werden die Teilnehmer in der Lage sein zu:

• Kafka-Producer und -Consumer zu erstellen, um Daten an Kafka zu senden bzw. von dort abzulesen.
• Kafka mithilfe von Kafka Connect mit externen Systemen zu integrieren.
• Echtzeit-Streaming-Anwendungen mittels Kafka Streams und ksqlDB zu programmieren.
• Eine Kafka-Client-Anwendung mit Confluent Cloud zu verbinden, um Cloud-basierte Kafka-Lösungen einzusetzen.
• Praktische Erfahrungen durch praxisnahe Übungen und reale Anwendungsbeispiele zu sammeln.

Dieses von einem Instruktor geleitete Live-Training in Leipzig (verfügbar online oder vor Ort) ist speziell für fortgeschrittene Entwickler konzipiert, die lernen möchten, Microservices unter Verwendung von Spring Boot, Docker und Kubernetes zu entwickeln.

Nach Abschluss dieses Trainings werden die Teilnehmer in der Lage sein:

• Die grundlegenden Prinzipien der Microservices-Architektur zu verstehen.
• Mittels Spring Boot produktionsreife Microservices zu erstellen.
• Den entscheidenden Beitrag von Docker bei der Containerisierung solcher Dienste nachzuvollziehen.
• Kubernetes-Cluster einzurichten, um die Bereitstellung und Verwaltung der Microservices zu gewährleisten.

Dieses praxisorientierte Live-Training unter Leitung eines Dozenten in Leipzig (online oder vor Ort) richtet sich an Entwickler sowie DevOps-Ingenieure mittleren Kenntnisstands, die lernen möchten, wie man Microservices mit Spring Cloud und Docker entwickelt, bereitstellt und verwaltet.

Am Ende dieser Schulung werden die Teilnehmer in der Lage sein zu:

• Microservices unter Verwendung von Spring Boot und Spring Cloud zu entwickeln.
• Anwendungen mithilfe von Docker sowie Docker Compose in Container zu verpacken.
• Dienstfindung, API-Gateways sowie die Kommunikation zwischen Microservices umzusetzen.
• Microservices in Produktivumgebungen zu überwachen und zu schützen.
• Microservices mithilfe von Kubernetes bereitzustellen und zu orchestrieren.

Dieses von einem Trainer geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Entwickler und Architekten mittleren bis fortgeschrittenen Kenntnisstands, die Java-Native-Anwendungen sowie Microservices mit Quarkus entwickeln möchten – wobei besonderes Augenmerk auf eine optimierte Speichernutzung und schnelle Startzeiten gelegt wird.

Nach Abschluss dieses Trainings werden die Teilnehmer in der Lage sein zu:

• Hochleistungsfähige, schlanke Java-Native-Anwendungen mit Quarkus zu entwickeln.
• RESTful-Dienste sowie Microservice-Architekturen zu erstellen und bereitzustellen.
• GraalVM zur nativen Kompilierung einzusetzen, um Startzeit und Speichernutzung zu optimieren.
• Anwendungen für die Verwendung in Kubernetes- und OpenShift-Umgebungen zu packen und containerisieren.

Dieses von einem Instruktor geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Softwarearchitekten und Webentwickler, die RabbitMQ als Nachrichten-Middleware nutzen möchten sowie Java-Programme mit Spring entwickeln wollen.

Am Ende des Kurses werden die Teilnehmer folgende Fähigkeiten erlangen:

• Java und Spring im Zusammenspiel mit RabbitMQ zur Entwicklung von Anwendungen einsetzen können.
• Asynchrone, nachrichtenbasierte Systeme mithilfe von RabbitMQ entwerfen.
• Warteschlangen, Topics, Wechselstellen und Bindungen in RabbitMQ erstellen sowie anwenden.

In diesem praxisorientierten Workshop unter Anleitung eines Experten erlernen die Teilnehmer, wie man RabbitMQ installiert, konfiguriert und verwaltet sowie anschließend die Messaging-Funktionen von RabbitMQ in mehreren Beispielanwendungen basierend auf .NET integriert.

Am Ende der Schulung werden die Teilnehmer folgende Fähigkeiten beherrschen:

• RabbitMQ einrichten, konfigurieren und verwalten.
• Die Rolle von RabbitMQ beim Entwurf und bei der Implementierung einer Microservices-Architektur verstehen.
• Den Vergleich zwischen RabbitMQ und anderen Messaging-Architekturen nachvollziehen können.
• RabbitMQ als Broker zur Verarbeitung asynchroner sowie synchroner Nachrichten in realen Enterprise-.NET-Anwendungen nutzen.

Dieses vom Instruktor geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Entwickler und Softwareingenieure, die RabbitMQ nutzen möchten, um per Nachrichtenaustausch Kommunikation zwischen Microservices zu ermöglichen sowie fortgeschrittene Implementierungen vorzunehmen und Probleme zu beheben.

Am Ende des Trainings werden die Teilnehmer in der Lage sein:

• Die erforderliche Umgebung einzurichten, um mit RabbitMQ fortgeschrittene Nachrichtenlösungen zu entwickeln.
• Zu verstehen, wie man eine verteilte Microservices-Architektur unter Verwendung von RabbitMQ gestaltet.
• Fortgeschrittene Konfigurationen sowie Sicherheitsmaßnahmen, Netzwerkeinstellungen, hohe Verfügbarkeit und Replikation umzusetzen.
• Häufig auftretende Probleme bei der Installation von RabbitMQ zu erkennen und deren Lösung zu kennen.
• Speicheroptimierung, Flusskontrolle sowie fortgeschrittenes Performance-Tuning zu beherrschen.
• Auch komplexere Fehlerbehebungsmethoden anzuwenden.

In diesem praxisorientierten Training unter Anleitung eines Trainers in Leipzig (online oder vor Ort) lernen die Teilnehmer, wie sie eine Python-Anwendung entkoppeln und anschließend mit dem RabbitMQ-Nachrichtenystem integrieren können, um verteilte Cloud-Anwendungen bzw. Microservices zu erstellen.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein:

• RabbitMQ einzurichten, zu konfigurieren und zu verwalten.
• die Rolle von RabbitMQ bei der Gestaltung und Umsetzung einer Microservice-Architektur zu verstehen.
• zu erkennen, wie RabbitMQ sich im Vergleich zu anderen Nachrichtenwarteschlangen-Architekturen verhält.
• RabbitMQ als Broker einzusetzen, um sowohl asynchrone als auch synchrone Nachrichten in echten Python-Anwendungen zu verarbeiten.

Dieses von einem Trainer geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Entwickler, die lernen möchten, wie man eine API auf der Apigee-API-Plattform von Google Cloud erstellt, testet, debuggt und bereitstellt.

Am Ende dieses Trainings werden die Teilnehmer in der Lage sein zu:

• Eine Entwicklungsumgebung einzurichten, die alle notwendigen Ressourcen für die API-Entwicklung enthält.
• Die in Apigee Edge verfügbaren Werkzeuge zu verstehen und anzuwenden.
• Eine API auf Google Cloud zu erstellen und bereitzustellen.
• API-Fehler zu überwachen und zu debuggen.
• Die Analysen- sowie Maschinellern-Lösungen von Google Cloud zu nutzen, um APIs intelligenter zu gestalten.

Dieser Kurs bietet eine umfassende, praxisnahe Einführung in das Entwerfen, Erstellen und Betreiben cloud-nativer Mikrodienste. Der Fokus liegt dabei auf der praktischen Umsetzung statt auf rein theoretischen Aspekten – von der Domänenmodellierung über die Serviceentwicklung bis hin zur Bereitstellung sowie zu Zuverlässigkeit und Überwachbarkeit in Produktionsumgebungen.

Die Teilnehmer arbeiten an der Entwicklung einer echten Mikrodienstarchitektur, lernen dabei, typische Fehler wie die Bildung verteilter Monolithen zu vermeiden und bewährte Methoden zur Skalierbarkeit, Wartbarkeit sowie betrieblichen Exzellenz anzuwenden.

Diese von einem Trainer geleitete Präsenz- oder Online-Schulung in Leipzig richtet sich an Systemadministratoren sowie MQ-Administratoren, die ihre Fähigkeiten im Bereich der fortgeschrittenen Konfiguration, Sicherheit, Cluster-Bildung, hohen Verfügbarkeit und Fehlerbehebung bei IBM MQ 9.4 in verteilten Umgebungen ausbauen möchten.

Dieses vom Dozenten geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Systemadministratoren und Operations-Ingenieure auf Anfänger-, Mittel- oder fortgeschrittenem Niveau, die Apache Kafka nutzen möchten, um Kafka-Cluster im Produktivumfeld zu installieren, abzusichern, zu überwachen sowie Fehler zu beheben.

Am Ende des Kurses werden die Teilnehmer in der Lage sein, die Architektur von Kafka und den KRaft-Modus zu erklären, Cluster sicher betreiben und sichern, deren Leistung sowie Zuverlässigkeit überwachen und typische Produktionsprobleme lösen.

Dieser Kurs bietet eine praktische Einführung in das Design, die Entwicklung, das Bereitstellen und das Verwalten von cloud-nativen Microservices auf Amazon Web Services (AWS). Die Teilnehmer erkunden die Prinzipien der Microservices-Architektur, die Docker-basierte Entwicklung sowie die ereignisgesteuerte Kommunikation und asynchrone Nachrichtenübermittlung unter Verwendung von Diensten wie Amazon SQS, SNS und EventBridge.

Der Kurs behandelt den gesamten Lebenszyklus von Microservices, einschließlich der Bereitstellung mit Amazon ECS und AWS Lambda, der API-Verwaltung mit Amazon API Gateway, der Observability mit CloudWatch, AWS X-Ray und OpenTelemetry sowie wesentlicher Konzepte zu Sicherheit, CI/CD und Infrastructure as Code. Im Rahmen praxisorientierter Übungen erstellen und verbinden die Teilnehmer verteilte Dienste und gewinnen praktische Erfahrung mit den zentralen AWS-Technologien, die in modernen Microservices-Architekturen verwendet werden.

In diesem praxisorientierten Live-Training vor Ort Leipzig lernen die Teilnehmer, wie man Microservices mit Go (Golang) und Spring Cloud entwickelt.

Dieses von einem Experten geleitete Live-Training in Leipzig (online oder vor Ort) richtet sich an Softwareentwickler mit mittlerem Erfahrungsstand, Systemarchitekten sowie DevOps-Fachkräfte, die skalierbare und wartbare Anwendungen unter Einsatz einer Microservice-Architektur entwickeln möchten.

Am Ende des Kurses werden die Teilnehmer in der Lage sein zu:

• Die Kernprinzipien der Microservice-Architektur verstehen.
• Skalierbare Systeme auf Basis von Microservices entwerfen und implementieren.
• Gängige Designmuster sowie bewährte Praktiken im Umgang mit Microservices anwenden.
• Ereignisgesteuerte Ansätze wie CQRS und Event Sourcing umzusetzen.
• Herausforderungen bei der Systembetriebsführung sowie der Implementierung von Microservices zu meistern.

In diesem praxisorientierten Kurs unter Anleitung eines Experten lernen die Teilnehmenden in Leipzig die Grundlagen der Erstellung von Microservices mithilfe von Spring Cloud und Docker. Durch zahlreiche Übungen sowie die schrittweise Entwicklung exemplarischer Microservices werden ihre Kenntnisse vertieft.

Am Ende des Kurses sind die Teilnehmenden in der Lage:

• Die Grundprinzipien von Microservices zu verstehen.
• Docker einzusetzen, um Container für Microservice-Anwendungen zu erstellen.
• Containerisierte Microservices mit Spring Cloud und Docker zu entwickeln und bereitzustellen.
• Microservices in Kombination mit Service-Discovery-Mechanismen sowie dem Spring Cloud API Gateway zu integrieren.
• Docker Compose für umfassende Integrationstests zu nutzen.