Container und virtuelle Maschinen (VMs) Schulungen in Frankfurt am Main

Dieses von einem Dozenten geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an fortgeschrittene Kubernetes-Administratoren sowie DevOps-Ingenieure, die ihre Fähigkeiten zur Überwachung von Kubernetes-Clustern mit Hilfe von Prometheus und Grafana weiter ausbauen möchten.

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

• Prometheus und Grafana für die Überwachung von Kubernetes einzurichten.
• Wichtige Metriken zu Pods, Knoten und Diensten zu überwachen.
• Dynamische Dashboards zu erstellen, um den Zustand sowie die Leistung des Clusters darzustellen.
• Warnstrategien zu implementieren, damit Probleme frühzeitig erkannt werden können.
• Bewährte Vorgehensweisen zur Skalierung der Monitoring-Lösungen in Kubernetes-Umgebungen anzuwenden.

Diese präsenzgebundene Live-Schulung in Frankfurt am Main (online oder vor Ort) richtet sich an DevOps-Engineers und Entwickler, die mit Kubernetes Container und Clusterkomponenten in einer sicheren und skalierbaren Umgebung aufbauen, bereitstellen und verwalten möchten.

Am Ende dieser Schulung sind die Teilnehmer in der Lage:

• Die Architektur, die Kernkonzepte und die Komponenten eines Kubernetes-Ökosystems zu verstehen.
• Ein Kubernetes-Cluster für die Container-Orchestrierung einzurichten, zu installieren und zu konfigurieren.
• Zu lernen, wie Kubernetes-Befehle über Kommandozeilentools ausgeführt werden.
• Eine praktische Erfahrung von grundlegenden bis hin zu fortgeschrittenen Kubernetes-Betriebs- und Verwaltungsaufgaben zu sammeln.

In diesem praxisorientierten Training unter Anleitung eines Instruktors in Frankfurt am Main (vor Ort oder remote) erlernen die Teilnehmer, wie man mehrere Beispielserver in Containern installiert und anschließend automatisiert, skaliert sowie verwaltet. Daraufhin werden fortgeschrittene Themen behandelt – insbesondere Absicherung, Vernetzung und Überwachung eines Kubernetes-Clusters.

Nach Abschluss dieses Kurses können die Teilnehmer:

• Einen Docker-Container einrichten und ausführen.
• Containerisierte Datenbanken sowie Server bereitstellen.
• Ein Docker- und Kubernetes-Cluster konfigurieren.
• Mit Kubernetes verschiedene Umgebungen innerhalb desselben Clusters verwalten.
• Einen Kubernetes-Cluster absichern, skalieren und überwachen.

Dieses praxisorientierte Training unter Leitung eines Instruktors in Frankfurt am Main (online oder vor Ort) richtet sich an Fachkräfte mit Grundkenntnissen, die lernen möchten, containerisierte Anwendungen mithilfe von Kubernetes effizient zu verwalten und auszubauen.

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

• die Architektur sowie Komponenten von Kubernetes zu verstehen,
• Ressourcen mithilfe von Namespaces effektiv voneinander abzugrenzen,
• Workloads mit Deployments, StatefulSets und DaemonSets zu steuern und anzupassen,
• Berechnungsressourcen über Requests und Limits zu definieren,
• mit Jobs sowie CronJobs zeitgesteuerte Aufgaben auszuführen,
• Services sowie das DNS-Verfahren in Kubernetes zu verstehen,
• Anwendungen durch Ingress zugänglich zu machen,
• ConfigMaps, Secrets sowie Persistent Volumes zu verwalten,
• Kubernetes-Cluster mithilfe fortgeschrittener Methoden zu skalieren und zu aktualisieren,
• Probleme in Kubernetes-Umgebungen zu analysieren und zu beheben,
• Ressourcen effizient mittels Helm Charts bereitzustellen.

Dieses praxisorientierte Live-Training unter Leitung eines Trainers in Frankfurt am Main (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 Frankfurt am Main (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.

In diesem praxisorientierten Kurs lernen Softwareentwickler, DevOps-Ingenieure sowie IT-Fachkräfte die Grundlagen von Containern, Kubernetes und OpenShift kennen. Die Teilnehmer erlangen Kompetenzen im Erstellen containerisierter Anwendungen, deren Bereitstellung sowie in der Verwaltung von Kubernetes-Ressourcen. Zudem erfahren sie, wie OpenShift die Entwicklung moderner Anwendungen in Cloud- und hybriden Umgebungen effizient unterstützt.

Dieses von einem Instruktor geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an Entwickler mit ersten Erfahrungen, die die Grundlagen von Kubefirst kennenlernen möchten sowie wie es die Verwaltung von Kubernetes- und Swarm-Clustern im Unternehmensmaßstab erleichtert.

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

• Eine Entwicklungsumgebung für Kubefirst einzurichten.
• Ein grundlegendes Kubefirst-Programm zu schreiben und auszuführen.
• Code mit Kubefirst-Direktiven und Klauseln zu versehen.
• Die Kubefirst-API sowie zugehörige Bibliotheken zu nutzen.
• Kubefirst-Programme zu profilieren und zu debuggen.

Dieser von einem Instruktor geleitete Live-Kurs in Frankfurt am Main (online oder vor Ort) richtet sich an Entwickler sowie DevOps-Ingenieure mittleren Kenntnisstands, die Minikube als Teil ihres Entwicklungsprozesses nutzen möchten.

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

• Eine lokale Kubernetes-Umgebung mit Minikube einzurichten und zu verwalten.
• Anwendungen auf Minikube erfolgreich bereitzustellen, zu verwalten sowie zu debuggen.
• Minikube in ihre bestehenden CI/CD-Pipelines zu integrieren.
• Ihren Entwicklungsprozess mithilfe fortgeschrittener Minikube-Funktionen zu optimieren.
• Die bewährtesten Methoden für die lokale Kubernetes-Entwicklung anzuwenden.

Diese Live-Schulung durch einen Dozenten in Frankfurt am Main (online oder vor Ort) richtet sich an Systemadministratoren mit mittlerem Kenntnisstand, die Hyper-V-Umgebungen effektiv bereitstellen, verwalten und Fehler beheben möchten.

Nach Abschluss dieser Schulung werden die Teilnehmer in der Lage sein:

• Grundlagen der Virtualisierung zu verstehen und Hyper-V zu konfigurieren.
• Virtuelle Maschinen, VM-Speicher und Netzwerkverbindungen zu erstellen und zu verwalten.
• Erweiterte Hyper-V-Funktionen zu nutzen und Hyper-V-Umgebungen abzusichern.
• Die Hyper-V-Performance zu überwachen und zu optimieren.

Dieses praxisorientierte Live-Training unter Leitung eines Dozenten in Frankfurt am Main (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 Experten geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an Softwareentwickler sowie DevOps-Fachkräfte mit Grund- bis Mittelkenntnissen, die lernen möchten, wie man eine lokale Kubernetes-Umgebung mithilfe von Minikube einrichtet und verwaltet.

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

• Minikube auf ihrem lokalen Rechner zu installieren und zu konfigurieren.
• Die grundlegenden Konzepte sowie die Architektur von Kubernetes zu verstehen.
• Container mithilfe von kubectl und dem Minikube-Dashboard zu implementieren und zu verwalten.
• Dauerhaften Speicher sowie Netzwerklösungen für Kubernetes einzurichten.
• Minikube zur Entwicklung, zum Testen und zur Fehlerbehebung von Anwendungen zu nutzen.

Lernziele des Kurses: Erwerb von theoretischem Wissen sowie praktischen Fähigkeiten im Umgang mit Docker und Kubernetes.

In diesem von Instruktoren geleiteten Live-Kurs in Frankfurt am Main (vor Ort oder remote) erlernen die Teilnehmer, wie man Docker-Container erstellt und verwaltet sowie anschließend eine Beispielanwendung in einem Container bereitstellt. Zudem erfahren sie, wie sie containerisierte Anwendungen innerhalb eines Kubernetes-Clusters automatisieren, skalieren und administrieren können. Abschließend befasst sich der Kurs mit fortgeschrittenen Themen wie der Absicherung, Skalierung sowie Überwachung von Kubernetes-Cluster.

Am Ende des Kurses sind die Teilnehmer in der Lage:

• Docker-Container einzurichten und auszuführen.
• Einen containerisierten Server sowie eine Webanwendung bereitzustellen.
• Docker-Images zu erstellen und zu verwalten.
• Einen Docker- sowie Kubernetes-Cluster einzurichten.
• Mit Hilfe von Kubernetes eine Webanwendung in einem Cluster zu implementieren und zu verwalten.
• Einen Kubernetes-Cluster abzusichern, skalierbar zu gestalten und zu überwachen.

In diesem von einem Instruktor geleiteten Live-Training in Frankfurt am Main (online oder vor Ort) lernen die Teilnehmer, wie man eine containerbasierte Umgebung im Produktionsmaßstab unter Verwendung von Kubernetes auf AKS einrichtet und verwaltet.

Nach Abschluss dieses Trainings sind die Teilnehmer in der Lage zu:

• Kubernetes auf AKS zu konfigurieren und zu verwalten.
• Einen Kubernetes-Cluster bereitzustellen, zu verwalten sowie zu skalieren.
• Containerisierten (Docker-)Anwendungen auf Azure einzusetzen.
• Ein bestehendes Kubernetes-Setup von der lokalen Umgebung in die AKS Cloud zu migrieren.
• Kubernetes mit gängigen Drittanbieter-Software für kontinuierliche Integration (CI) zu integrieren.
• Hochverfügbarkeit und Notfallwiederherstellung in Kubernetes sicherzustellen.

Erlernen Sie die Methoden zum Bauen, Deployen und Verwalten von containerisierten Umgebungen unter Einsatz von Docker, Kubernetes und OpenShift. Dieses fünftägige Praxistraining behandelt Container-Images, Arbeitslastverwaltung bei Kubernetes, Cluster-Netzwerke, Speicherplatzverwaltung, Sicherheit sowie praktische OpenShift-Verwaltungsaufgaben. Die Teilnehmer erlangen Fähigkeiten zur Betreuung moderner Container-Plattformen sowie zum Lösen von Anwendungsproblemen in Entwicklungs- und Produktivumgebungen.

Dieser praxisnahe Kurs unter Anleitung eines Instruktors in Frankfurt am Main vermittelt den Teilnehmern ein grundlegendes Verständnis von Rancher und zeigt durch konkrete Übungen, wie man mithilfe dieser Plattform ein Kubernetes-Cluster bereitstellt sowie verwaltet.

Dieses von einem Dozenten geleitete Live-Training in <Ort> (online oder vor Ort) richtet sich an Ingenieure, die Helm nutzen möchten, um den Installations- und Verwaltungsprozess von Kubernetes-Anwendungen zu vereinfachen.

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

• Helm zu installieren und zu konfigurieren.
• Reproduzierbare Builds von Kubernetes-Anwendungen zu erstellen.
• Anwendungen als Helm-Charts zu teilen.
• Drittanbieter-Anwendungen, die als Helm-Charts vorliegen, auszuführen.
• Veröffentlichungen von Helm-Paketen zu verwalten.

Dieses vom Dozenten geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an DevOps-Ingenieure, die Kubernetes und GitLab nutzen möchten, um den gesamten DevOps-Zyklus zu automatisieren.

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

• Anwendungsbuilds, Tests sowie Bereitstellungen zu automatisieren.
• Eine automatisierte Build-Infrastruktur einzurichten.
• Eine Anwendung in einer containerisierten Cloud-Umgebung bereitzustellen.

Diese vom Dozenten gelebte, live durchgeführte Schulung in Frankfurt am Main (online oder vor Ort) richtet sich an Kubernetes-Praktiker, die sich auf die CKS-Prüfung vorbereiten möchten.

Nach Abschluss dieser Schulung wissen die Teilnehmer, wie sie Kubernetes-Umgebungen und containerbasierte Anwendungen in den verschiedenen Phasen des Anwendungszykles – Build, Deployment und Runtime – absichern.

Dieses von einem Trainer geleitete Live-Training in Frankfurt am Main – online oder vor Ort – richtet sich an Entwickler sowie DevOps-Ingenieure, die einen serverlosen Ansatz zur Entwicklung von Unternehmensanwendungen auf Kubernetes nutzen möchten.

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

• Das Kubernetes-System einzurichten und zu konfigurieren, um mit einer serverlosen Architektur zu arbeiten.
• Die Grundkonzepte und -prinzipien von serverlosen Umgebungen zu verstehen.
• Die für die Entwicklung in einem serverlosen Kontext erforderlichen Werkzeugketten zu nutzen und diese mit Kubernetes-Komponenten zu integrieren.
• Ihre Kenntnisse der Programmiersprache Python anzuwenden, um serverlose Systeme zu implementieren.
• Unternehmensanwendungen, die mithilfe eines serverlosen Frameworks auf Kubernetes bereitgestellt werden, abzusichern.
• Aktuelle Cloud-Computing-Methoden zur Optimierung von DevOps-Arbeitsabläufen einzusetzen.

Dieses vom Kursleiter geführte Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an Ingenieure, die den Sicherheitsstandard eines Kubernetes-Clusters über die Standardeinstellungen hinaus erweitern möchten.

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

• Die Schwachstellen zu erkennen, die durch eine Standard-Installation von Kubernetes entstehen.
• Nicht autorisierten Zugriff auf die Kubernetes-API, Datenbanken sowie andere Dienste zu verhindern.
• Einen Kubernetes-Cluster vor versehentlichem oder böswilligem Zugriff zu schützen.
• Eine umfassende Sicherheitsrichtlinie samt bewährten Praktiken zu erstellen.

Dieses von einem Trainer gelebte Live-Schulung in Frankfurt am Main (online oder vor Ort) richtet sich an Ingenieure, die ihre Docker-Kenntnisse vertiefen möchten, um Anwendungen im größeren Maßstab bereitzustellen, während sie die volle Kontrolle behalten.

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

• Eigene Docker-Images zu erstellen.
• Eine große Anzahl von Docker-Anwendungen bereitzustellen und zu verwalten.
• Verschiedene Container-Orchestrierungslösungen zu bewerten und die geeignetste auszuwählen.
• Einen Continuous-Integration-Prozess für Docker-Anwendungen einzurichten.
• Docker-Anwendungen mit bestehenden Continuous-Tool-Integrationsprozessen zu verbinden.
• Ihre Docker-Anwendungen abzusichern.

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

• Eigene Docker-Images zu erstellen.
• Große Mengen an Docker-Anwendungen zu deployen und zu verwalten.
• Verschiedene Lösungen zur Container-Orchestrierung zu bewerten und die am besten geeignete auszuwählen.
• Einen kontinuierlichen Integrationsprozess für Docker-Anwendungen einzurichten.
• Docker-Anwendungen in vorhandene Prozesse der kontinuierlichen Integration zu integrieren.
• Ihre Docker-Anwendungen abzusichern.
• Mithilfe von Kubernetes unterschiedliche Umgebungen unter einem gemeinsamen Cluster zu deployen und zu verwalten.
• Einen Kubernetes-Cluster sicher, skalierbar und überwachbar zu gestalten.

Dieses 7-tägige Programm bietet eine umfassende, praxisnahe Einführung in das Entwerfen, Bereitstellen und Betreiben cloudnativer Anwendungen mit modernen DevOps-Praktiken.

Die Teilnehmenden erfahren, wie sie skalierbare Microservice-Architekturen entwerfen, Container-Umgebungen optimieren und Produktionsworkloads unter Kubernetes verwalten. Der Kurs behandelt fortgeschrittene Bereitstellungsstrategien, GitOPs-basierte Automatisierung sowie Observability-Praktiken, um die Zuverlässigkeit und Leistungsfähigkeit der Systeme sicherzustellen.

Ein besonderes Augenmerk liegt auf operativen Herausforderungen in der Praxis, darunter Incident Response (Störungsmanagement), Failure Simulation (Ausfallsimulation) und Root-Cause-Analyse (Ursachenanalyse). Das Programm endet mit dem Einsatz KI-gestützter Tools zur Unterstützung bei der Fehlersuche und zur Beschleunigung operativer Entscheidungsprozesse.

Nach Abschluss der Schulung haben die Teilnehmenden ein klares Verständnis davon, wie man resiliente verteilte Systeme in einer Kubernetes-Umgebung aufbaut, bereitstellt, überwacht und wartet.

Dieses von einem Instruktor geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an erfahrene DevOps-Ingenieure und Systemadministratoren, die eigene Kubernetes-Clusters einrichten möchten – ohne Cloud-Abhängigkeiten.

Nach Abschluss des Trainings können Teilnehmer produktionsreife Cluster mithilfe von kubeadm installieren; hochverfügbare Steuerungsebenen und etcd-Cluster konfigurieren; Netzwerk- sowie Speicherlösungen für selbstverwaltete Umgebungen realisieren; zudem Monitoring- und Observability-Systeme eigenständig betreiben.

In diesem praxisorientierten Kurs unter Anleitung eines Experten lernen die Teilnehmenden in Frankfurt am Main 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.

OpenShift zählt zu den führenden Kubernetes-basierten Plattformen zur Bereitstellung und Verwaltung von containerisierten Anwendungen in Cloud-, Hybrid- und lokalen Umgebungen.

In diesem praxisorientierten Training erlernen die Teilnehmer, wie man OpenShift-Cluster installiert, verwaltet sowie Fehler behebt – dabei werden bewährte Verfahren zu Sicherheit, Netzwerk und Speicherverwaltung vermittelt. Durch realitätsnahe Übungen entwickeln sie die Fähigkeiten, OpenShift-Umgebungen im Produktivbetrieb selbstbewusst zu handhaben.

Erlernen Sie die Entwicklung, Bereitstellung und Verwaltung von containerisierten Anwendungen mithilfe von OpenShift – einer der führenden Kubernetes-basierten Plattformen für Cloud-native Entwicklungen. Dieses praxisnahe Training behandelt Themen wie Anwendungsbereitstellung, Containertechnologien, Netzwerkkonfiguration, CI/CD sowie DevOps-Workflows und vermittelt den Teilnehmern die Fähigkeiten, moderne Anwendungen erfolgreich in Produktionsumgebungen zu erstellen.

Dieses vom Trainer geleitete Live-Training in Frankfurt am Main (online oder vor Ort) richtet sich an Virtualisierungsadministratoren mittleren Kenntnisstands, die Open-Source-Plattformen nutzen möchten, um VMware zu ersetzen.

Nach Abschluss des Trainings können die Teilnehmer folgendes:

• KVM, oVirt sowie Proxmox VE installieren und konfigurieren.
• Virtuelle Arbeitslasten von VMware migrieren.
• Hochverfügbarkeit sowie Notfallwiederherstellung umsetzen.
• Die Leistung in Open-Source-Virtualisierungsumgebungen optimieren.