**Unterstützung für die Verbesserung dieser Seite beitragen**
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Was ist Amazon EKS?
**Tipp**
[Melden Sie sich](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) für bevorstehende Amazon EKS-Workshops an.
## Amazon EKS: Vereinfachtes Kubernetes-Management
Amazon Elastic Kubernetes Service (EKS) bietet einen vollständig verwalteten Kubernetes-Service, der die Komplexität des Betriebs von Kubernetes-Clustern beseitigt. Mit EKS können Sie:
+ Anwendungen schneller und mit weniger Betriebsaufwand bereitstellen.
+ Nahtlos skalieren, um sich ändernden Workload-Anforderungen gerecht zu werden
+ Verbessern Sie die Sicherheit durch AWS Integration und automatisierte Updates
+ Zwischen dem Standard-EKS und dem vollständig automatisierten EKS Auto Mode wählen
Amazon Elastic Kubernetes Service (Amazon EKS) ist die führende Plattform für den Betrieb von [Kubernetes](https://kubernetes.io/docs/concepts/overview/)-Clustern, sowohl in der Amazon Web Services (AWS)-Cloud als auch in Ihren eigenen Rechenzentren ([EKS Anywhere](https://anywhere.eks.amazonaws.com/) und [Amazon EKS Hybrid Nodes](hybrid-nodes-overview.md)).
Amazon EKS vereinfacht die Entwicklung, Sicherung und Wartung von Kubernetes-Clustern. Es kann kostengünstiger sein, ausreichend Ressourcen für Spitzennachfragen bereitzustellen, als eigene Rechenzentren zu betreiben. Zwei der wichtigsten Ansätze für die Nutzung von Amazon EKS sind wie folgt:
+ **EKS-Standard**: AWS verwaltet die [Kubernetes-Steuerebene](https://kubernetes.io/docs/concepts/overview/components/#control-plane-components), wenn Sie einen Cluster mit EKS erstellen. Komponenten, die Knoten verwalten, Workloads planen, in die AWS Cloud integrieren und Informationen zur Kontrollebene speichern und skalieren, damit Ihre Cluster am Laufen bleiben, werden automatisch für Sie verwaltet.
+ **EKS Auto Mode**: Mit dem Feature [EKS Auto Mode](automode.md) erweitert EKS seine Steuerungsfunktionen auch auf die Verwaltung von [Knoten](https://kubernetes.io/docs/concepts/overview/components/#node-components) (Kubernetes-Datenebene). Es vereinfacht das Kubernetes-Management, indem es automatisch die Infrastruktur bereitstellt, optimale Recheninstanzen auswählt, Ressourcen dynamisch skaliert, die Kosten kontinuierlich optimiert, Betriebssysteme patcht und Sicherheitsdienste integriert. AWS
Das folgende Diagramm zeigt, wie Amazon EKS Ihre Kubernetes-Cluster in die AWS Cloud integriert, je nachdem, welche Methode der Clustererstellung Sie wählen:
![\[Amazon EKS Standard und EKS Auto Mode\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/images/whatis.png)
Amazon EKS hilft Ihnen dabei, Reibungsverluste zu vermeiden und die Produktionszeit zu verkürzen, Leistung, Verfügbarkeit und Stabilität zu verbessern und die Systemsicherheit zu verbessern. Weitere Informationen finden Sie unter [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/).
## Aufbau und Skalierung mit Kubernetes: Amazon EKS-Funktionen
Amazon EKS unterstützt Sie nicht nur beim Aufbau und der Verwaltung von Clustern, sondern auch beim Aufbau und der Skalierung von Anwendungssystemen mit Kubernetes. [Amazon EKS Capabilities](capabilities.md) sind vollständig verwaltete Cluster-Services, die die Funktionalität Ihres Clusters um benutzerfreundliche Kubernetes-native Tools erweitern, darunter:
+ **Argo CD**: Argo CD bietet eine deklarative, kontinuierliche Bereitstellung für Ihre GitOps Workloads, Ressourcen und Cloud-Infrastruktur. AWS
+ ** AWS Controller for Kubernetes (ACK): ACK** ermöglicht die native Erstellung und das Lebenszyklusmanagement von Ressourcen auf Kubernetes-Ebene und vereinheitlicht so Workload-Orchestrierung und Workflows. AWS Infrastructure-as-code
+ **kro (Kube Resource Orchestrator)**: kro erweitert die nativen Kubernetes-Funktionen, um die Erstellung, Orchestrierung und Zusammenstellung benutzerdefinierter Ressourcen zu vereinfachen, und bietet Ihnen die Tools, mit denen Sie Ihre eigenen maßgeschneiderten Cloud-Bausteine erstellen können.
EKS-Funktionen sind Cloud-Ressourcen, die den betrieblichen Aufwand für die Installation, Wartung und Skalierung dieser grundlegenden Plattformkomponenten in Ihren Clustern minimieren, sodass Sie sich auf die Entwicklung von Software statt auf den Betrieb von Clusterplattformen konzentrieren können.
Weitere Informationen hierzu finden Sie unter [EKS-Fähigkeiten](capabilities.md).
## Features von Amazon EKS
Amazon EKS bietet die folgenden allgemeinen Feature:
**Verwaltungsschnittstellen**
EKS bietet mehrere Schnittstellen zur Bereitstellung, Verwaltung und Wartung von Clustern AWS-Managementkonsole, darunter Amazon EKS API/SDKs, CDK, AWS CLI, eksctl CLI und Terraform. AWS CloudFormation Weitere Informationen erhalten Sie unter [Erste Schritte mit Amazon EKS](getting-started.md) und [Lebenszyklus und Konfiguration des Amazon-EKS-Clusters](clusters.md).
**Tools zur Zugriffskontrolle**
EKS stützt sich sowohl auf Kubernetes- als auch auf AWS Identity and Access Management (AWS IAM) -Funktionen, um den [Zugriff von Benutzern und Workloads zu verwalten](cluster-auth.md). Weitere Informationen erhalten Sie unter [Gewähren Sie IAM-Benutzern und -Rollen Zugriff auf Kubernetes APIs](grant-k8s-access.md) und [Kubernetes-Workloads Zugriff auf AWS mithilfe von Kubernetes-Servicekonten gewähren](service-accounts.md).
**Ressourcen berechnen**
Für [Rechenressourcen](eks-compute.md) ermöglicht EKS die gesamte Palette der EC2 Amazon-Instance-Typen und AWS Innovationen wie Nitro und Graviton mit Amazon EKS, sodass Sie die Rechenleistung für Ihre Workloads optimieren können. Weitere Informationen finden Sie unter [Verwaltung von Datenverarbeitungsressourcen mithilfe von Knoten](eks-compute.md).
**Speicherung**
EKS Auto Mode erstellt automatisch Speicherklassen unter Verwendung von [EBS-Volumes](create-storage-class.md). Mithilfe von CSI-Treibern (Container Storage Interface) können Sie auch Amazon S3, Amazon EFS, Amazon FSX und Amazon File Cache für die Speicheranforderungen Ihrer Anwendungen nutzen. Weitere Informationen finden Sie unter [Verwendung von Anwendungsdatenspeichern für Ihren Cluster](storage.md).
**Sicherheit**
In Bezug auf die [Sicherheit in Amazon EKS](security.md) wird das Modell der geteilten Verantwortung angewendet. Weitere Informationen finden Sie unter [Bewährte Verfahren für die Sicherheit](security-best-practices.md), [Infrastruktursicherheit](infrastructure-security.md) und [Kubernetes-Sicherheit](security-k8s.md).
**Tools zur Überwachung**
Verwenden Sie für die Überwachung von Amazon-EKS-Clustern das [Dashboard zur Beobachtbarkeit](observability-dashboard.md). [Zu den Überwachungstools gehören [Prometheus [CloudWatch](cloudwatch.md)](prometheus.md), [Cloudtrail](logging-using-cloudtrail.md) und ADOT Operator.](opentelemetry.md) Weitere Informationen zu Dashboards, Metriken-Servern und anderen Tools finden Sie unter [EKS-Cluster-Kosten](cost-monitoring.md) und [Kubernetes Metrics Server](metrics-server.md).
**Cluster-Fähigkeiten**
EKS bietet verwaltete Cluster-Funktionen für die kontinuierliche Bereitstellung, Cloud-Ressourcenverwaltung und Ressourcenzusammensetzung auf der Grundlage von Open-Source-Innovationen. EKS installiert Kubernetes APIs in Ihren Clustern, aber Controller und andere Komponenten laufen in EKS und werden vollständig verwaltet, sodass automatisiertes Patchen, Skalieren und Überwachen möglich ist. Weitere Informationen finden Sie unter [EKS-Fähigkeiten](capabilities.md).
**Kubernetes-Kompatibilität und -Unterstützung**
Amazon EKS ist als Kubernetes-konform zertifiziert, sodass Sie Kubernetes-kompatible Anwendungen ohne Refactoring bereitstellen und die Tools und Plugins der Kubernetes-Community nutzen können. EKS bietet sowohl [Standard-Support](kubernetes-versions-standard.md) als auch [erweiterten Support](kubernetes-versions-extended.md) für Kubernetes an. Weitere Informationen finden Sie unter [Verständnis des Kubernetes-Versionslebenszyklus auf EKS](kubernetes-versions.md).
## Zugehörige Services
**Services zur Verwendung mit Amazon EKS**
Sie können andere AWS Services mit den Clustern verwenden, die Sie mit Amazon EKS bereitstellen:
**Amazon EC2**
Besorgen Sie sich skalierbare Rechenkapazität auf Abruf mit [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html).
**Amazon EBS**
Fügen Sie mit [Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html) skalierbare, leistungsstarke Blockspeicherressourcen hinzu.
**Amazon ECR**
Speichern Sie Container-Images sicher mit [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html).
**Amazon CloudWatch**
Überwachen Sie AWS Ressourcen und Anwendungen in Echtzeit mit [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html).
**Amazon Prometheus**
Verfolgen Sie Metriken für containerisierte Anwendungen mit [Amazon Managed Service für Prometheus](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html).
**Elastic Load Balancing**
Verteilen Sie eingehenden Datenverkehr mit [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) auf mehrere Ziele.
**Amazon GuardDuty**
Erkennen Sie mit [Amazon](integration-guardduty.md) Bedrohungen für EKS-Cluster GuardDuty.
** AWS Resilience Hub**
Bewerten Sie die Ausfallsicherheit des EKS-Clusters mit [AWS Resilience Hub](integration-resilience-hub.md).
## Preisgestaltung von Amazon EKS
Amazon EKS bietet Preise pro Cluster basierend auf dem Support für die Kubernetes-Cluster-Version, Preise für Amazon EKS Auto Mode und Preise pro vCPU für Amazon EKS Hybrid Nodes.
Wenn Sie Amazon EKS verwenden, zahlen Sie separat für die AWS Ressourcen, die Sie für die Ausführung Ihrer Anwendungen auf Kubernetes-Worker-Knoten verwenden. Wenn Sie beispielsweise Kubernetes-Worker-Knoten als EC2 Amazon-Instances mit Amazon EBS-Volumes und öffentlichen IPv4 Adressen ausführen, werden Ihnen die Instance-Kapazität über Amazon EC2, die Volume-Kapazität über Amazon EBS und die IPv4 Adresse über Amazon VPC in Rechnung gestellt.
Detaillierte Preisinformationen finden Sie auf den jeweiligen Preisseiten der AWS Services, die Sie mit Ihren Kubernetes-Anwendungen nutzen.
+ Die Preise für Amazon EKS-Cluster, Amazon EKS Auto Mode, Amazon EKS-Funktionen und Amazon EKS-Hybridknoten finden Sie unter [Amazon EKS-Preise](https://aws.amazon.com/eks/pricing/).
+ EC2 Die Amazon-Preise finden Sie unter [Amazon EC2 On-Demand-Preise](https://aws.amazon.com/ec2/pricing/on-demand/) und [Amazon EC2 Spot-Preise](https://aws.amazon.com/ec2/spot/pricing/).
+ Informationen zu AWS Fargate-Preisen finden Sie unter [AWS Fargate-Preise](https://aws.amazon.com/fargate/pricing).
+ Sie können Ihre Savings Plans für die in Amazon-EKS-Clustern genutzte Rechenleistung verwenden. Weitere Informationen finden Sie unter [Preise und Savings Plans](https://aws.amazon.com/savingsplans/pricing/).
# Häufige Anwendungsfälle in Amazon EKS
Amazon EKS bietet robuste verwaltete Kubernetes-Services, die darauf ausgelegt sind AWS, containerisierte Anwendungen zu optimieren. Im Folgenden finden Sie einige der häufigsten Anwendungsfälle von Amazon EKS, die Ihnen dabei helfen, die Stärken von Amazon EKS für Ihre spezifischen Anforderungen zu nutzen.
**Bereitstellung von Anwendungen mit hoher Verfügbarkeit**
Mit [Elastic Load Balancing](https://aws.amazon.com/elasticloadbalancing/) können Sie sicherstellen, dass Ihre Anwendungen über mehrere [Availability Zones](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) hinweg hochverfügbar sind.
**Entwicklung von Microservices-Architekturen**
Verwenden Sie die Serviceerkennungs-Feature von Kubernetes mit [AWS Cloud Map](https://aws.amazon.com/cloud-map/) oder [Amazon VPC Lattice](https://aws.amazon.com/vpc/lattice/), um ausfallsichere Systeme zu erstellen.
**Automatisierung von Softwareveröffentlichungsprozessen**
Verwalten Sie CI/CD-Pipelines (Continuous Integration and Continuous Deployment), die den Prozess der automatisierten Erstellung, Prüfung und Bereitstellung von Anwendungen vereinfachen. Informationen zur deklarativen kontinuierlichen Bereitstellung finden Sie unter Kontinuierliche Bereitstellung mit [Argo](argocd.md) CD.
**Serverlose Anwendungen ausführen**
Verwenden Sie [AWS Fargate](https://aws.amazon.com/fargate/) mit Amazon EKS, um Serverless-Anwendungen auszuführen. Das bedeutet, dass Sie sich ausschließlich auf die Anwendungsentwicklung konzentrieren können, während Amazon EKS und Fargate die zugrunde liegende Infrastruktur verwalten.
**Ausführung von Workloads für maschinelles Lernen**
Amazon EKS ist mit gängigen Machine-Learning-Frameworks wie [TensorFlow](https://www.tensorflow.org/), [MXNet](https://mxnet.apache.org/) und [PyTorch](https://pytorch.org/) kompatibel. Mit GPU-Unterstützung können Sie selbst komplexe Machine-Learning-Aufgaben effektiv bewältigen.
**Konsistente Bereitstellung vor Ort und in der Cloud**
Um die Ausführung von Kubernetes in On-Premises-Umgebungen zu vereinfachen, können Sie dieselben Amazon-EKS-Cluster, -Features und -Tools verwenden, um selbstverwaltete Knoten in [AWS Outposts](eks-outposts.md) auszuführen, oder Sie können [Amazon EKS Hybrid Nodes](hybrid-nodes-overview.md) mit Ihrer eigenen Infrastruktur nutzen. Für in sich geschlossene, Air-Gap-Umgebungen können Sie [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/) verwenden, um die Lebenszyklusverwaltung von Kubernetes-Clustern auf Ihrer eigenen Infrastruktur zu automatisieren.
**Ausführung kostengünstiger Batch-Verarbeitungs- und Big-Data-Workloads**
Nutzen Sie [Spot Instances](https://aws.amazon.com/ec2/spot/), um Ihre Batch-Verarbeitungs- und Big-Data-Workloads wie [Apache Hadoop](https://aws.amazon.com/emr/details/hadoop/what-is-hadoop/) und [Spark](https://aws.amazon.com/big-data/what-is-spark/) zu einem Bruchteil der Kosten auszuführen. Auf diese Weise können Sie ungenutzte EC2 Amazon-Kapazitäten zu ermäßigten Preisen nutzen.
** AWS Ressourcen von Kubernetes aus verwalten**
Verwenden Sie [AWS Controllers for Kubernetes (ACK)](ack.md), um AWS Ressourcen mit nativem Kubernetes direkt von Ihrem Kubernetes-Cluster aus zu erstellen und zu verwalten. APIs
**Abstraktionen für die Plattformtechnik erstellen**
Erstellen Sie mithilfe von [kro](kro.md) (Kube APIs Resource Orchestrator) benutzerdefinierte Kubernetes, die mehrere Ressourcen zu Abstraktionen auf höherer Ebene zusammensetzen.
**Sicherung von Anwendungen und Sicherstellung der Einhaltung von Vorschriften**
Implementieren Sie strenge Sicherheitspraktiken und sorgen Sie für die Einhaltung der Vorschriften mit Amazon EKS, das in AWS Sicherheitsservices wie [AWS Identity and Access Management](https://aws.amazon.com/iam/) (IAM), [Amazon Virtual Private Cloud](https://aws.amazon.com/vpc/) (Amazon VPC) und [AWS Key Management Service](https://aws.amazon.com/kms/) (AWS KMS) integriert ist. Dadurch werden der Datenschutz und die Datensicherheit gemäß den Branchenstandards gewährleistet.
# Amazon-EKS-Architektur
Amazon EKS entspricht der allgemeinen Cluster-Architektur von Kubernetes. Weitere Informationen finden Sie unter [Kubernetes-Komponente](https://kubernetes.io/docs/concepts/overview/components/) in der Kubernetes-Dokumentation. In den folgenden Abschnitten werden einige zusätzliche Architekturdetails für Amazon EKS zusammengefasst.
## Steuerebene
Amazon EKS sorgt dafür sicher, dass jeder Cluster über eine eigene, eindeutige Kubernetes-Steuerebene verfügt. Bei diesem Design bleibt die Infrastruktur jedes Clusters getrennt, sodass es keine Überschneidungen zwischen Clustern oder Konten gibt. AWS Das Setup beinhaltet:
**Verteilte Komponenten**
Die Kontrollebene positioniert mindestens zwei API-Serverinstanzen und drei [etcd-Instanzen](https://etcd.io/) in drei AWS Availability Zones innerhalb einer AWS Region.
**Optimale Leistung**
Amazon EKS überwacht und passt die Instances der Steuerebene aktiv an, um eine Spitzenleistung aufrechtzuerhalten.
**Ausfallsicherheit**
Wenn eine Kontrollebeneninstanz ins Stocken gerät, ersetzt Amazon EKS sie schnell und verwendet bei Bedarf eine andere Availability Zone.
**Konsistente Verfügbarkeit**
Durch den Betrieb von Clustern in mehreren Availability Zones wird ein zuverlässiges [Service Level Agreement (SLA) für die Verfügbarkeit von API-Server-Endpunkten](https://aws.amazon.com/eks/sla) erzielt.
Amazon EKS verwendet Amazon Virtual Private Cloud (Amazon VPC), um den Datenverkehr zwischen Komponenten der Steuerebene innerhalb eines einzelnen Clusters zu begrenzen. Clusterkomponenten können keine Kommunikation von anderen Clustern oder AWS Konten anzeigen oder empfangen, es sei denn, dies ist durch die Richtlinien für die rollenbasierte Zugriffskontrolle (RBAC) von Kubernetes autorisiert.
## Datenverarbeitung
Zusätzlich zur Steuerebene verfügt ein Amazon-EKS-Cluster über eine Reihe von Worker-Computern, die als Knoten bezeichnet werden. Die Auswahl des geeigneten Amazon-EKS-Cluster-Knotentyps ist entscheidend, um Ihre spezifischen Anforderungen zu erfüllen und die Ressourcennutzung zu optimieren. Amazon EKS bietet die folgenden Primärknotentypen:
**EKS Auto Mode**
Der [EKS Auto Mode](automode.md) erweitert die AWS Verwaltung über die Steuerungsebene hinaus auf die Datenebene und automatisiert so die Verwaltung der Cluster-Infrastruktur. Er integriert zentrale Kubernetes-Funktionen als integrierte Komponenten, darunter automatische Skalierung der Rechenleistung, Netzwerke, Lastenausgleich, DNS, Speicher und GPU-Unterstützung. Der automatische Modus von EKS verwaltet Knoten dynamisch auf der Grundlage der Arbeitslastanforderungen und verwendet unveränderliche Funktionen AMIs mit erweiterten Sicherheitsfunktionen. Er automatisiert Aktualisierungen und Upgrades unter Berücksichtigung der Budgets für Pod-Unterbrechung und umfasst verwaltete Komponenten, die andernfalls eine zusätzliche Verwaltung erfordern würden. Diese Option ist ideal für Benutzer, die AWS Fachwissen für den day-to-day Betrieb nutzen, den Betriebsaufwand minimieren und sich auf die Anwendungsentwicklung statt auf die Infrastrukturverwaltung konzentrieren möchten.
** AWS Fargate**
[Fargate](fargate.md) ist eine Serverless-Compute-Engine für Container, die die Verwaltung der zugrunde liegenden Instances überflüssig macht. Mit Fargate spezifizieren Sie den Ressourcenbedarf Ihrer Anwendung und stellen die Infrastruktur AWS automatisch bereit, skalieren und warten. Diese Option ist ideal für Benutzer, die Prioritäten setzen ease-of-use und sich auf die Anwendungsentwicklung und -bereitstellung konzentrieren möchten, anstatt die Infrastruktur zu verwalten.
**Karpenter**
[Karpenter](https://karpenter.sh/) ist ein flexibler, leistungsstarker Kubernetes-Cluster-Autoscaler, der zur Verbesserung der Anwendungsverfügbarkeit und Cluster-Effizienz beiträgt. Karpenter stellt als Reaktion auf die sich ändernde Anwendungslast Rechenressourcen in der richtigen Größe bereit. Mit dieser Option können just-in-time Rechenressourcen bereitgestellt werden, die den Anforderungen Ihrer Arbeitslast entsprechen.
**Verwaltete Knotengruppen**
[Verwaltete Knotengruppen](managed-node-groups.md) sind eine Mischung aus Automatisierung und Anpassung für die Verwaltung einer Sammlung von EC2 Amazon-Instances innerhalb eines Amazon EKS-Clusters. AWS kümmert sich um Aufgaben wie das Patchen, Aktualisieren und Skalieren von Knoten und vereinfacht so betriebliche Aspekte. Gleichzeitig werden benutzerdefinierte `kubelet`-Argumente unterstützt, die Möglichkeiten für erweiterte CPU- und Speicherverwaltungsrichtlinien eröffnen. Darüber hinaus verbessern sie die Sicherheit durch AWS Identity and Access Management (IAM) -Rollen für Dienstkonten und reduzieren gleichzeitig den Bedarf an separaten Berechtigungen pro Cluster.
**Selbstverwaltete Knoten**
[Selbstverwaltete Knoten](worker.md) bieten die volle Kontrolle über Ihre EC2 Amazon-Instances innerhalb eines Amazon EKS-Clusters. Sie sind für die Verwaltung, Skalierung und Wartung der Knoten zuständig und haben somit die volle Kontrolle über die zugrunde liegende Infrastruktur. Diese Option eignet sich für Benutzer, die eine differenzierte Kontrolle und Anpassung ihrer Knoten benötigen und bereit sind, Zeit in die Verwaltung und Wartung ihrer Infrastruktur zu investieren.
**Amazon EKS Hybrid Nodes**
Mit [Amazon EKS Hybrid Nodes](hybrid-nodes-overview.md) können Sie Ihre On-Premises- und Edge-Infrastruktur als Knoten in Amazon-EKS-Clustern verwenden. Amazon EKS Hybrid Nodes vereinheitlicht das Kubernetes-Management in allen Umgebungen und verlagert die Verwaltung der Kubernetes-Steuerungsebene auf AWS Ihre lokalen und Edge-Anwendungen.
## EKS-Funktionen
Amazon EKS bietet vollständig verwaltete Cluster-Funktionen und installiert und verwaltet Kubernetes APIs (mit benutzerdefinierten Kubernetes-Ressourcendefinitionen) in Ihrem Cluster, während Controller und andere Komponenten in einer AWS eigenen Infrastruktur betrieben werden, die von Ihrem Cluster getrennt ist. EKS bietet automatisiertes Patchen, Skalieren und Überwachen dieser Funktionen und verwaltet deren gesamten Lebenszyklus, um den Aufwand für den Betrieb von Cluster-Services für Workload-Orchestrierung, Ressourcenmanagement und mehr zu reduzieren. AWS
EKS bietet die folgenden Funktionstypen:
** AWS Controller für Kubernetes (ACK)**
AWS Mit [Controllers for Kubernetes (ACK)](ack.md) können Sie AWS Ressourcen mithilfe von Kubernetes verwalten und S3-Buckets APIs, RDS-Datenbanken, IAM-Rollen und andere Ressourcen als benutzerdefinierte Kubernetes-Ressourcen definieren. AWS Sie können AWS Ressourcen zusammen mit Ihren Kubernetes-Workloads mithilfe derselben Tools und Workflows verwalten, wobei mehr als 50 AWS Dienste unterstützt werden, darunter S3, RDS, DynamoDB und Lambda.
**Argo CD**
[Argo CD](argocd.md) implementiert ein GitOps basiertes kontinuierliches Deployment für Ihre Anwendungs-Workloads, AWS Ressourcen und Cluster-Konfigurationen, wobei Git-Repositorys als Quelle der Wahrheit verwendet werden. Argo CD synchronisiert Ihre Cluster automatisch mit Ihren Git-Repositorys, erkennt Abweichungen und gleicht sie kontinuierlich ab, um sicherzustellen, dass Ihre bereitgestellten Anwendungen und Ressourcen Ihrem gewünschten Status in der Versionskontrolle entsprechen. Sie können Argo CD verwenden, um Anwendungen auf einem bestimmten Cluster zu verwalten, oder Anwendungen über mehrere Cluster von einer einzigen Argo-CD-Ressource aus bereitstellen und verwalten, wobei die automatische Bereitstellung aus Git-Repositorys erfolgt, wann immer Änderungen festgeschrieben werden.
**kro (Kube Resource Orchestrator)**
[kro (Kube Resource Orchestrator)](kro.md) ermöglicht es Ihnen, benutzerdefinierte Kubernetes zu erstellen, die mehrere Ressourcen zu Abstraktionen auf höherer Ebene zusammensetzen APIs , sodass Plattformteams wiederverwendbare Muster für gängige Ressourcenkombinationen definieren können. Auf diese Weise können Plattformteams Self-Service-Funktionen mit entsprechenden Leitplanken bereitstellen, sodass Entwickler komplexe Infrastrukturen mithilfe einfacher, speziell entwickelter Systeme bereitstellen und gleichzeitig die organisatorischen Standards und Best Practices einhalten können. APIs
# Kubernetes-Konzepte
Amazon Elastic Kubernetes Service (Amazon EKS) ist ein AWS-verwalteter Service, der auf dem Open-Source-Projekt [Kubernetes](https://kubernetes.io/) basiert. Es gibt Dinge, die Sie über die Integration des Amazon-EKS-Services in die AWS Cloud wissen müssen (insbesondere, wenn Sie zum ersten Mal einen Amazon-EKS-Cluster erstellen), aber sobald er betriebsbereit ist, verwenden Sie Ihren Amazon-EKS-Cluster auf die gleiche Weise wie jeden anderen Kubernetes-Cluster. Um mit der Verwaltung von Kubernetes-Clustern und dem Bereitstellen von Workloads zu beginnen, benötigen Sie daher zumindest ein grundlegendes Verständnis der Kubernetes-Konzepte.
Auf dieser Seite werden die Kubernetes-Konzepte in drei Abschnitte unterteilt: [Warum Kubernetes?](#why-kubernetes), [Cluster](#concepts-clusters) und [Workloads](#workloads). Der erste Abschnitt beschreibt den Wert der Ausführung eines Kubernetes-Services, insbesondere als verwalteter Service wie Amazon EKS. Der Abschnitt „Workloads“ behandelt, wie Kubernetes-Anwendungen erstellt, gespeichert, ausgeführt und verwaltet werden. Im Abschnitt „Cluster“ werden die verschiedenen Komponenten erläutert, aus denen Kubernetes-Cluster bestehen, und welche Aufgaben Sie beim Erstellen und Verwalten von Kubernetes-Clustern haben.
**Topics**
+ [Warum Kubernetes?](#why-kubernetes)
+ [Cluster](#concepts-clusters)
+ [Workloads](#workloads)
+ [Nächste Schritte](#next-steps)
Beim Durchgehen dieser Inhalte führen Sie Links zu weiteren Beschreibungen der Kubernetes-Konzepte in der Amazon-EKS- und Kubernetes-Dokumentation, falls Sie tiefer in die hier behandelten Themen eintauchen möchten. Weitere Informationen zur Implementierung der Kubernetes-Steuerebene und der Rechenfunktionen in Amazon EKS finden Sie unter [Amazon-EKS-Architektur](eks-architecture.md).
## Warum Kubernetes?
Kubernetes wurde entwickelt, um die Verfügbarkeit und Skalierbarkeit beim Ausführen unternehmenskritischer containerisierter Anwendungen in Produktionsqualität zu verbessern. Anstatt Kubernetes nur auf einem einzelnen Rechner auszuführen (obwohl dies möglich ist), erreicht Kubernetes diese Ziele, indem es Ihnen ermöglicht, Anwendungen auf einer Reihe von Rechnern auszuführen, die je nach Bedarf erweitert oder reduziert werden können. Kubernetes enthält Funktionen, die Ihnen Folgendes vereinfachen:
+ Anwendungen auf mehreren Rechnern (mithilfe von in Pods bereitgestellten Containern) bereitstellen
+ Container-Zustand und Neustart ausgefallener Container überwachen
+ Container je nach Auslastung nach oben und unten zu skalieren
+ Container mit neuen Versionen aktualisieren
+ Ressourcen zwischen Containern zuzuweisen
+ Datenverkehr über mehrere Rechner hinweg ausgleichen
Durch die Automatisierung dieser komplexen Aufgaben durch Kubernetes kann sich ein Anwendungsentwickler auf die Erstellung und Verbesserung seiner Anwendungs-Workloads konzentrieren, anstatt sich um die Infrastruktur zu kümmern. Der Entwickler erstellt in der Regel Konfigurationsdateien im YAML-Format, die den gewünschten Zustand der Anwendung beschreiben. Dies kann beispielsweise die auszuführenden Container, Ressourcenlimits, die Anzahl der Pod-Replikate, die CPU-/Speicherzuweisung, Affinitätsregeln und mehr beinhalten.
### Eigenschaften von Kubernetes
Um seine Ziele zu erreichen, verfügt Kubernetes über die folgenden Eigenschaften:
+ **Containerisiert** – Kubernetes ist ein Container-Orchestrierungstool. Um Kubernetes verwenden zu können, müssen Sie zunächst Ihre Anwendungen containerisieren. Je nach Art der Anwendung kann dies als eine Reihe von *Microservices*, als Batch-Aufträge oder in anderen Formen erfolgen. Anschließend können Ihre Anwendungen die Vorteile eines Kubernetes-Workflows nutzen, der ein umfangreiches Ökosystem von Tools beinhaltet, in dem Container als [Images in einer Container-Registry](https://kubernetes.io/docs/concepts/containers/images/#multi-architecture-images-with-image-indexes) gespeichert, in einem Kubernetes-[Cluster](https://kubernetes.io/docs/concepts/architecture/) bereitgestellt und in einem verfügbaren [Knoten](https://kubernetes.io/docs/concepts/architecture/nodes/) ausgeführt werden können. Sie können einzelne Container auf Ihrem lokalen Computer mit Docker oder einer anderen [Container-Laufzeitumgebung](https://kubernetes.io/docs/setup/production-environment/container-runtimes/) erstellen und testen, bevor Sie sie in Ihrem Kubernetes-Cluster bereitstellen.
+ **Skalierbar** – Wenn die Nachfrage nach Ihren Anwendungen die Kapazität der auszuführenden Instances dieser Anwendungen übersteigt, kann Kubernetes entsprechend hochskaliert werden. Bei Bedarf kann Kubernetes erkennen, ob Anwendungen mehr CPU oder Speicher benötigen, und darauf reagieren, indem es entweder automatisch die verfügbare Kapazität erweitert oder mehr der vorhandenen Kapazität nutzt. Die Skalierung kann auf Pod-Ebene erfolgen, wenn genügend Rechenleistung für die Ausführung mehrerer Anwendungs-Instances zur Verfügung steht ([horizontale Pod-Autoskalierung](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/)), oder auf Knotenebene, wenn mehr Knoten für die erhöhte Kapazität hochgefahren werden müssen ([Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler) oder [Karpenter](https://karpenter.sh/)). Da keine Kapazität mehr benötigt wird, können diese Services unnötige Pods löschen und nicht mehr benötigte Knoten herunterfahren.
+ **Verfügbar** – Wenn eine Anwendung oder ein Knoten fehlerhaft oder nicht mehr verfügbar ist, kann Kubernetes die ausgeführten Workloads auf einen anderen verfügbaren Knoten verschieben. Sie können das Problem beheben, indem Sie einfach eine ausgeführte Instance einer Workload oder einen Knoten löschen, auf dem Ihre Workload ausgeführt wird. Im Endeffekt können Workloads an anderen Standorten hochgefahren werden, wenn sie dort nicht mehr ausgeführt werden können.
+ **Deklarativ** – Kubernetes verwendet aktive Abstimmung, um ständig zu überprüfen, ob der von Ihnen für Ihren Cluster deklarierte Status mit dem tatsächlichen Status übereinstimmt. Durch die Anwendung von [Kubernetes-Objekten](https://kubernetes.io/docs/concepts/overview/working-with-objects/) auf einen Cluster, in der Regel über Konfigurationsdateien im YAML-Format, können Sie beispielsweise den Start der Workloads anfordern, die Sie in Ihrem Cluster ausführen möchten. Sie können die Konfigurationen später ändern, um beispielsweise eine neuere Version eines Containers zu verwenden oder mehr Speicher zuzuweisen. Kubernetes wird die erforderlichen Maßnahmen ergreifen, um den gewünschten Zustand herzustellen. Dazu gehört unter anderem das Hoch- oder Herunterfahren von Knoten, das Beenden und Neustarten von Workloads oder das Abrufen aktualisierter Container.
+ **Zusammensetzbar** – Da eine Anwendung in der Regel aus mehreren Komponenten besteht, ist es wünschenswert, eine Reihe dieser Komponenten (oft durch mehrere Container repräsentiert) gemeinsam verwalten zu können. Während Docker Compose eine Möglichkeit bietet, dies direkt mit Docker zu tun, kann Ihnen der Befehl Kubernetes [Kompose](http://kompose.io/) dabei helfen, dies mit Kubernetes zu erreichen. Ein Beispiel hierfür finden Sie unter [Übersetzen einer Docker-Compose-Datei in Kubernetes-Ressourcen](https://kubernetes.io/docs/tasks/configure-pod-container/translate-compose-kubernetes/).
+ **Erweiterbar** – Im Gegensatz zu proprietärer Software ist das Open-Source-Projekt Kubernetes so konzipiert, dass Sie Kubernetes beliebig erweitern können, um Ihren Anforderungen gerecht zu werden. APIs und Konfigurationsdateien können direkt geändert werden. Drittanbieter werden aufgefordert, eigene [Controller](https://kubernetes.io/docs/concepts/architecture/controller/) zu schreiben, um sowohl die Infrastruktur- als auch die Endbenutzer-Feature von Kubernetes zu erweitern. Mit [Webhooks](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/) können Sie Cluster-Regeln einrichten, um Richtlinien durchzusetzen und sich an veränderte Bedingungen anzupassen. Weitere Informationen zur Erweiterung von Kubernetes-Clustern finden Sie unter [Erweiterung von Kubernetes](https://kubernetes.io/docs/concepts/extend-kubernetes/).
+ **Portabel** – Viele Unternehmen haben ihre Abläufe in Kubernetes standardisiert, da sie damit alle ihre Anwendungsanforderungen auf einheitliche Weise verwalten können. Entwickler können dieselben Pipelines zum Entwickeln und Speichern von containerisierten Anwendungen verwenden. Diese Anwendungen können dann in Kubernetes-Clustern bereitgestellt werden, die On-Premises, in Clouds, auf POS-Terminals in Restaurants oder auf IoT-Geräten an Fern-Standorten des Unternehmens ausgeführt werden. Da es sich um eine Open-Source-Software handelt, können Nutzer diese speziellen Kubernetes-Distributionen sowie die für deren Verwaltung erforderlichen Tools entwickeln.
### Verwaltung von Kubernetes
Der Quellcode von Kubernetes ist kostenlos verfügbar, sodass Sie Kubernetes mit Ihrer eigenen Ausrüstung selbst installieren und verwalten können. Die eigenständige Verwaltung von Kubernetes erfordert jedoch fundierte Fachkenntnisse und ist mit einem erheblichen Zeit- und Arbeitsaufwand verbunden. Aus diesen Gründen entscheiden sich die meisten Anwender, die Produktions-Workloads bereitstellen, für einen Cloud-Anbieter (z. B. Amazon EKS) oder einen On-Premises-Anbieter (z. B. Amazon EKS Anywhere) mit einer eigenen erprobten Kubernetes-Verteilung und Support durch Kubernetes-Experten. Dadurch können Sie einen Großteil der undifferenzierten, aufwändigen Aufgaben, die für die Wartung Ihrer Cluster erforderlich sind, auslagern, darunter:
+ **Hardware** – Wenn Sie nicht über die erforderliche Hardware verfügen, um Kubernetes gemäß Ihren Anforderungen auszuführen, können Sie mit einem Cloud-Anbieter wie AWS Amazon EKS Vorabkosten einsparen. Mit Amazon EKS können Sie die besten Cloud-Ressourcen von AWS nutzen. Dazu gehören Computer-Instances (Amazon Elastic Compute Cloud), Ihre eigene private Umgebung (Amazon VPC), zentrale Identitäts- und Berechtigungsverwaltung (IAM) und Speicher (Amazon EBS). AWS verwaltet die Computer, Netzwerke, Rechenzentren und alle anderen physischen Komponenten, die für den Betrieb von Kubernetes erforderlich sind. Ebenso müssen Sie Ihr Rechenzentrum nicht für die maximale Kapazität an Tagen mit höchster Auslastung auslegen. Bei Amazon EKS Anywhere oder anderen On-Premises-Kubernetes-Clustern sind Sie für die Verwaltung der in Ihren Kubernetes-Bereitstellungen verwendeten Infrastruktur verantwortlich, können sich jedoch weiterhin auf AWS verlassen, um Kubernetes auf dem neuesten Stand zu halten.
+ **Verwaltung der Steuerebene** – Amazon EKS verwaltet die Sicherheit und Verfügbarkeit der von AWS gehosteten Kubernetes-Steuerebene, die für die Planung von Containern, die Verwaltung der Anwendungsverfügbarkeit und andere wichtige Aufgaben verantwortlich ist, sodass Sie sich auf Ihre Anwendungs-Workloads konzentrieren können. Wenn Ihr Cluster ausfällt, sollte AWS über die erforderlichen Mittel verfügen, um Ihren Cluster wieder in einen auszuführenden Status zu versetzen. Bei Amazon EKS Anywhere verwalten Sie die Steuerebene selbst.
+ **Geprüfte Upgrades** – Bei der Aktualisierung Ihrer Cluster können Sie sich darauf basieren, dass Amazon EKS oder Amazon EKS Anywhere geprüfte Versionen ihrer Kubernetes-Verteilungen bereitstellen.
+ **Add-Ons** – Es gibt Hunderte von Projekten, die für die Erweiterung und Arbeit mit Kubernetes entwickelt wurden und die Sie der Infrastruktur Ihres Clusters hinzufügen oder zur Unterstützung der Ausführung Ihrer Workloads verwenden können. Anstatt diese Add-Ons selbst zu entwickeln und zu verwalten, stellt AWS [Amazon-EKS-Add-ons](eks-add-ons.md) bereit, die Sie mit Ihren Clustern verwenden können. Amazon EKS Anywhere bietet [kuratierte Pakete](https://anywhere.eks.amazonaws.com/docs/packages/), die Entwicklungen vieler beliebter Open-Source-Projekte enthalten. Daher ist es nicht erforderlich, die Software selbst zu entwickeln oder wichtige Sicherheitspatches, Fehlerbehebungen oder Upgrades zu verwalten. Wenn die Standardeinstellungen Ihren Anforderungen entsprechen, ist in der Regel nur ein sehr geringer Konfigurationsaufwand für diese Add-Ons erforderlich. Weitere Informationen zur Erweiterung Ihres Clusters mit Add-Ons finden Sie unter [Cluster erweitern](#extend-clusters).
### Kubernetes in Aktion
Das folgende Diagramm zeigt die wichtigsten Aktivitäten, die Sie als Kubernetes-Administrator oder Anwendungsentwickler zum Erstellen und zur Nutzung eines Kubernetes-Clusters durchführen würden. Dabei wird veranschaulicht, wie Kubernetes-Komponenten miteinander interagieren. Die AWS Cloud dient dabei als Beispiel für den zugrunde liegenden Cloud-Anbieter.
![\[Ein Kubernetes-Cluster in Aktion.\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/images/k8sinaction.png)
Ein Kubernetes-Administrator erstellt den Kubernetes-Cluster mit einem Tool, das speziell auf den Anbietertyp zugeschnitten ist, auf dem der Cluster entwickelt wird. In diesem Beispiel wird die AWS Cloud als Anbieter verwendet, der den verwalteten Kubernetes-Service Amazon EKS bereitstellt. Der verwaltete Service weist automatisch die zum Erstellen des Clusters erforderlichen Ressourcen zu. Dazu gehört das Erstellen von zwei neuen Virtual Private Clouds (Amazon VPCs) für den Cluster, die Einrichtung des Netzwerks und die Zuordnung von Kubernetes-Berechtigungen zu den neuen VPCs für die Verwaltung von Cloud-Ressourcen. Der verwaltete Service stellt außerdem sicher, dass die Services der Steuerebene über ausreichend Platz zum Ausführen verfügen, und weist null oder mehr Amazon-EC2-Instances als Kubernetes-Knoten zum Ausführen von Workloads zu. AWS verwaltet selbst eine Amazon VPC für die Steuerebene, während die andere Amazon VPC die Kundenknoten enthält, die Workloads ausführen.
Viele Aufgaben des Kubernetes-Administrators werden in Zukunft mithilfe von Kubernetes-Tools wie `kubectl` ausgeführt. Dieses Tool stellt Service-Anfragen direkt an die Steuerebene des Clusters. Die Vorgehensweise bei Abfragen und Änderungen am Cluster entspricht im Wesentlichen der Vorgehensweise, die Sie bei jedem Kubernetes-Cluster anwenden würden.
Ein Anwendungsentwickler, der Workloads in diesem Cluster bereitstellen möchte, kann mehrere Aufgaben ausführen. Der Entwickler muss die Anwendung in ein oder mehrere Container-Images integrieren und diese Images dann in ein Container-Registry übertragen, auf das der Kubernetes-Cluster zugreifen kann. AWS bietet hierfür das Amazon Elastic Container Registry (Amazon ECR) an.
Um die Anwendung auszuführen, kann der Entwickler Konfigurationsdateien im YAML-Format erstellen, die dem Cluster mitteilen, wie die Anwendung ausgeführt werden soll, einschließlich der Angabe, welche Container aus der Registry abgerufen und wie diese Container in Pods verpackt werden sollen. Die Steuerebene (Scheduler) plant die Container für einen oder mehrere Knoten ein und die Container-Laufzeit auf jedem Knoten ruft die benötigten Container ab und führt sie aus. Der Entwickler kann auch einen Application Load Balancer einrichten, um den Datenverkehr auf die verfügbaren Container zu verteilen, die im jeweiligen Knoten ausgeführt werden, und die Anwendung so freizugeben, dass sie in einem öffentlichen Netzwerk für die Außenwelt verfügbar ist. Anschließend kann sich jeder, der die Anwendung nutzen möchte, mit dem Anwendungsendpunkt verbinden und darauf zugreifen.
In den folgenden Abschnitten werden die einzelnen Features aus der Perspektive von Kubernetes-Clustern und -Workloads detailliert beschrieben.
## Cluster
Wenn Sie Kubernetes-Cluster starten und verwalten, sollten Sie wissen, wie Kubernetes-Cluster erstellt, erweitert, verwaltet und gelöscht werden. Sie sollten außerdem wissen, aus welchen Komponenten ein Cluster besteht und wie Sie diese Komponenten warten.
Tools zur Cluster-Verwaltung verwalten die Überschneidungen zwischen den Kubernetes-Services und dem zugrunde liegenden Hardware-Anbieter. Aus diesem Grund wird die Automatisierung dieser Aufgaben in der Regel vom Kubernetes-Anbieter (z. B. Amazon EKS oder Amazon EKS Anywhere) mithilfe von anbieterspezifischen Tools durchgeführt. Um beispielsweise einen Amazon-EKS-Cluster zu starten, können Sie `eksctl create cluster` verwenden, während Sie für Amazon EKS Anywhere `eksctl anywhere create cluster` verwenden können. Beachten Sie, dass diese Befehle zwar einen Kubernetes-Cluster erstellen, jedoch spezifisch für den Anbieter sind und nicht Teil des Kubernetes-Projekts selbst sind.
### Tools zur Erstellung und Verwaltung von Clustern
Das Kubernetes-Projekt bietet Tools zur manuellen Erstellung eines Kubernetes-Clusters. Wenn Sie Kubernetes auf einem einzelnen Rechner installieren oder die Steuerebene auf einem Rechner ausführen und Knoten manuell hinzufügen möchten, können Sie CLI-Tools wie [kind](https://kind.sigs.k8s.io/), [minikube](https://kubernetes.io/docs/tutorials/hello-minikube/) oder [kubeadm](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/) verwenden, die unter Kubernetes-[Installations-Tools](https://kubernetes.io/docs/tasks/tools/) aufgeführt sind. Um den gesamten Lebenszyklus der Cluster-Erstellung und -Verwaltung zu vereinfachen und zu automatisieren, ist es viel einfacher, Tools zu verwenden, die von einem etablierten Kubernetes-Anbieter unterstützt werden, wie z. B. Amazon EKS oder Amazon EKS Anywhere.
In der AWS Cloud können Sie Cluster von [Amazon EKS](https://docs.aws.amazon.com/eks/) mithilfe von CLI-Tools wie [eksctl](https://eksctl.io/) oder deklarativeren Tools wie Terraform erstellen (siehe [Amazon-EKS-Vorlagen für Terraform](https://github.com/aws-ia/terraform-aws-eks-blueprints)). Sie können auch einen Cluster aus dem AWS-Managementkonsole erstellen. Eine Liste der Funktionen von Amazon EKS finden Sie unter [Amazon-EKS-Feature](https://aws.amazon.com/eks/features/). Zu den Kubernetes-Aufgaben, die Amazon EKS für Sie übernimmt, gehören:
+ **Verwaltete Steuerebene** – AWS stellt sicher, dass der Amazon-EKS-Cluster verfügbar und skalierbar ist, da es die Steuerebene für Sie verwaltet und sie über Availability Zones von AWS hinweg verfügbar macht.
+ **Knotenverwaltung** – Anstatt Knoten manuell hinzuzufügen, können Sie Amazon EKS Knoten bei Bedarf automatisch erstellen lassen, indem Sie verwaltete Knotengruppen (siehe [Vereinfachung des Knotenlebenszyklus mit verwalteten Knotengruppen](managed-node-groups.md)) oder [Karpenter](https://karpenter.sh/) verwenden. Verwaltete Knotengruppen verfügen über Integrationen mit Kubernetes [Cluster Autoscaling](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md). Mithilfe von Knotenverwaltungstools können Sie Kosteneinsparungen erzielen, beispielsweise durch [Spot Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) und Knotenkonsolidierung, sowie die Verfügbarkeit verbessern, indem Sie Feature zur [Planung](https://karpenter.sh/docs/concepts/scheduling/) verwenden, um festzulegen, wie Workloads bereitgestellt und Knoten ausgewählt werden.
+ **Cluster-Netzwerk** – `eksctl` richtet mithilfe von CloudFormation-Vorlagen das Netzwerk zwischen Steuerebenen- und Datenebenenkomponenten (Knoten) im Kubernetes-Cluster ein. Außerdem werden Endpunkte für die interne und externe Kommunikation eingerichtet. Weitere Informationen finden Sie unter [Entmystifizierung von Cluster-Netzwerken für Amazon-EKS-Worker-Knoten](https://aws.amazon.com/blogs/containers/de-mystifying-cluster-networking-for-amazon-eks-worker-nodes). Die Kommunikation zwischen Pods in Amazon EKS erfolgt mithilfe von Amazon EKS Pod Identities (siehe [Erfahren Sie, wie EKS Pod Identity Pods Zugriff auf AWS-Services gewährt](pod-identities.md)), wodurch Pods auf AWS-Cloud-Methoden zur Verwaltung von Anmeldeinformationen und Berechtigungen zugreifen können.
+ **Add-Ons** – Mit Amazon EKS entfällt die Notwendigkeit, Software-Komponenten zu erstellen und hinzuzufügen, die üblicherweise zur Unterstützung von Kubernetes-Clustern verwendet werden. Wenn Sie beispielsweise einen Amazon-EKS-Cluster aus dem AWS-Managementkonsole erstellen, werden automatisch die Amazon-EKS-Add-Ons kube-proxy ([Verwaltung von `kube-proxy` in Amazon-EKS-Clustern](managing-kube-proxy.md)), Amazon-VPC-CNI-Plugin für Kubernetes ([Pods mit dem Amazon VPC CNI zuweisen IPs](managing-vpc-cni.md)) und CoreDNS ([CoreDNS für DNS in Amazon EKS-Clustern verwalten](managing-coredns.md)) hinzugefügt. Weitere Informationen zu diesen Add-Ons, einschließlich einer Liste der verfügbaren Add-Ons, finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md).
Um Ihre Cluster auf Ihren eigenen On-Premises-Computern und -Netzwerken auszuführen, bietet Amazon [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/) an. Anstatt die AWS Cloud als Anbieter zu verwenden, haben Sie die Möglichkeit, Amazon EKS Anywhere in [VMWare vSphere](https://anywhere.eks.amazonaws.com/docs/getting-started/vsphere/), [bare metal](https://anywhere.eks.amazonaws.com/docs/getting-started/baremetal/) ([Tinkerbell-Anbieter](https://tinkerbell.org)), [Snow](https://anywhere.eks.amazonaws.com/docs/getting-started/snow/), [CloudStack](https://anywhere.eks.amazonaws.com/docs/getting-started/cloudstack/) oder [Nutanix](https://anywhere.eks.amazonaws.com/docs/getting-started/nutanix/)-Plattformen mithilfe Ihrer eigenen Ausrüstung auszuführen.
Amazon EKS Anywhere basiert auf derselben [Amazon EKS Distro](https://distro.eks.amazonaws.com/)-Software, die auch von Amazon EKS verwendet wird. Amazon EKS Anywhere basiert jedoch auf verschiedenen Implementierungen der [Kubernetes Cluster API](https://cluster-api.sigs.k8s.io/) (CAPI)-Benutzeroberfläche, um den gesamten Lebenszyklus der Rechner in einem Cluster von Amazon EKS Anywhere zu verwalten (z. B. [CAPV](https://github.com/kubernetes-sigs/cluster-api-provider-vsphere) für vSphere und [CAPC](https://github.com/kubernetes-sigs/cluster-api-provider-cloudstack) für CloudStack). Da der gesamte Cluster auf Ihrer Ausrüstung ausgeführt wird, übernehmen Sie die zusätzliche Verantwortung für die Verwaltung der Steuerebene und die Datensicherung (siehe`etcd` weiter unten in diesem Dokument).
### Cluster-Komponenten
Die Komponenten eines Kubernetes-Clusters lassen sich in zwei Hauptbereiche unterteilen: die Steuerebene und die Worker-Knoten. [Komponente der Steuerebene](https://kubernetes.io/docs/concepts/overview/components/#control-plane-components) verwalten den Cluster und bieten Zugriff auf seine APIs. Worker-Knoten (manchmal auch einfach als Knoten bezeichnet) stellen die Orte bereit, an denen die eigentlichen Workloads ausgeführt werden. [Knotenkomponente](https://kubernetes.io/docs/concepts/overview/components/#node-components) bestehen aus Services, die in jedem Knoten ausgeführt werden, um mit der Steuerebene zu kommunizieren und Container auszuführen. Die Gruppe der Worker-Knoten, die für Ihren Cluster festgelegt ist, wird als *Datenebene* bezeichnet.
#### Steuerebene
Die Steuerebene besteht aus einer Reihe von Services, die den Cluster verwalten. Diese Services können alle auf einem einzigen Computer ausgeführt werden oder auf mehrere Computer verteilt sein. Intern werden diese als Instances der Steuerebene (CPIs) bezeichnet. Die Ausführung von CPIs hängt von der Größe des Clusters und den Anforderungen an die Hochverfügbarkeit ab. Bei steigender Nachfrage im Cluster kann ein Service der Steuerebene skaliert werden, um mehr Instances dieses Services bereitzustellen, wobei die Anfragen zwischen den Instances lastverteilt werden.
Zu den Aufgaben, die von Komponenten der Kubernetes-Steuerebene ausgeführt werden, gehören:
+ **Kommunikation mit Cluster-Komponenten (API-Server)** – Der API-Server ([kube-apiserver](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/)) stellt die Kubernetes-API bereit, sodass Anfragen an den Cluster sowohl innerhalb als auch außerhalb des Clusters gestellt werden können. Mit anderen Worten: Anforderungen zum Hinzufügen oder Ändern von Objekten eines Clusters (Pods, Services, Knoten usw.) können von externen Befehlen stammen, beispielsweise Anforderungen von `kubectl` zum Ausführen eines Pods. Ebenso können vom API-Server Anfragen an Komponenten innerhalb des Clusters gestellt werden, beispielsweise eine Abfrage an den `kubelet`-Service zum Status eines Pods.
+ **Speichern von Daten über den Cluster (`etcd`-Schlüsselwertspeicher)** – Der `etcd`-Service übernimmt die wichtige Aufgabe, den aktuellen Status des Clusters zu verfolgen. Wenn der `etcd`-Service nicht mehr erreichbar ist, können Sie den Status des Clusters nicht mehr aktualisieren oder abfragen, obwohl die Workloads noch eine Weile ausgeführt werden. Aus diesem Grund werden in kritischen Clustern in der Regel mehrere Instances des `etcd`-Services mit Lastausgleich gleichzeitig ausgeführt und regelmäßige Backups des `etcd`-Schlüsselwertspeichers für den Fall eines Datenverlusts oder einer Datenbeschädigung durchgeführt. Denken Sie daran, dass dies alles in Amazon EKS standardmäßig automatisch für Sie erledigt wird. Amazon EKS Anywhere bietet Anweisungen für die [Sicherung und Wiederherstellung von etcd](https://anywhere.eks.amazonaws.com/docs/clustermgmt/etcd-backup-restore/). Informationen darüber, wie `etcd` Daten verwaltet, finden Sie im [etcd-Datenmodell](https://etcd.io/docs/v3.5/learning/data_model/).
+ **Pods für Knoten planen (Scheduler)** – Anfragen zum Starten oder Stoppen eines Pods in Kubernetes werden an den [Kubernetes Scheduler](https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/) ([kube-scheduler](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-scheduler/)) weitergeleitet. Da ein Cluster über mehrere Knoten verfügen kann, auf denen der Pod ausgeführt werden kann, muss Scheduler auswählen, in welchem Knoten (oder auf welchen Knoten im Falle von Replikaten) der Pod ausgeführt werden soll. Wenn nicht genügend Kapazität verfügbar ist, um den angeforderten Pod in einem vorhandenen Knoten auszuführen, schlägt die Anforderung fehl, sofern Sie keine anderen Vorkehrungen getroffen haben. Zu diesen Vorkehrungen könnte die Aktivierung von Services wie verwaltete Knotengruppen ([Vereinfachung des Knotenlebenszyklus mit verwalteten Knotengruppen](managed-node-groups.md)) oder [Karpenter](https://karpenter.sh/) gehören, die automatisch neue Knoten starten können, um die Workloads zu bewältigen.
+ **Komponenten im gewünschten Zustand halten (Controller Manager)** – Der Kubernetes Controller Manager wird als Daemon-Prozess ([kube-controller-manager](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-controller-manager/)) ausgeführt, um den Zustand des Clusters zu überwachen und Änderungen am Cluster vorzunehmen, um die erwarteten Zustände wiederherzustellen. Insbesondere gibt es mehrere Controller, die verschiedene Kubernetes-Objekte überwachen, darunter `statefulset-controller`, `endpoint-controller`, `cronjob-controller`, `node-controller` und andere.
+ **Verwalten von Cloud-Ressourcen (Cloud Controller Manager)** – Die Interaktionen zwischen Kubernetes und dem Cloud-Anbieter, der die Anfragen für die zugrunde liegenden Rechenzentrumsressourcen ausführt, werden vom [Cloud Controller Manager](https://kubernetes.io/docs/concepts/architecture/cloud-controller/) ([cloud-controller-manager](https://github.com/kubernetes/kubernetes/tree/master/cmd/cloud-controller-manager)) verwaltet Zu den vom Cloud Controller Manager verwalteten Controllern können ein Route Controller (für die Einrichtung von Cloud-Netzwerkweiterleitungen), ein Service Controller (für die Nutzung von Cloud-Lastausgleichsservices) und ein Knoten-Lebenszyklus-Controller (um Knoten während ihres Lebenszyklus mit Kubernetes synchron zu halten) gehören.
#### Worker-Knoten (Datenebene)
Bei einem Kubernetes-Cluster mit einem Knoten werden Workloads auf demselben Rechner wie die Steuerebene ausgeführt. Eine gängigere Konfiguration ist jedoch ein oder mehrere separate Computersysteme ([Knoten](https://kubernetes.io/docs/concepts/architecture/nodes/)), die für die Ausführung von Kubernetes-Workloads vorgesehen sind.
Wenn Sie zum ersten Mal einen Kubernetes-Cluster erstellen, können Sie mit einigen Tools zur Cluster-Erstellung eine bestimmte Anzahl von Knoten konfigurieren, die dem Cluster hinzugefügt werden sollen (entweder durch die Identifizierung vorhandener Computersysteme oder durch die Erstellung neuer Systeme durch den Anbieter). Bevor Workloads zu diesen Systemen hinzugefügt werden, werden jedem Knoten Services hinzugefügt, um diese Features zu implementieren:
+ **Knoten einzeln verwalten (`kubelet`)** – Der API-Server kommuniziert mit dem [Kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)-Service, der in jedem Knoten ausgeführt wird, um sicherzustellen, dass der Knoten ordnungsgemäß registriert ist und die vom Scheduler angeforderten Pods ausgeführt werden. Das Kubelet kann die Pod-Manifeste lesen und Speicher-Volumes oder andere von den Pods benötigte Feature auf dem lokalen System einrichten. Es kann auch den Zustand der lokal ausgeführten Container überprüfen.
+ **Container in einem Knoten ausführen (Container-Laufzeit)** – Die [Container-Laufzeit](https://kubernetes.io/docs/setup/production-environment/container-runtimes/) in jedem Knoten verwaltet die Container, die für jeden dem Knoten zugewiesenen Pod angefordert werden. Das bedeutet, dass es Container-Images aus der entsprechenden Registry abrufen, den Container starten und anhalten kann und auf Anfragen zum Container antwortet. Die Standard-Container-Laufzeit ist [containerd](https://github.com/containerd/containerd/blob/main/docs/getting-started.md). Ab Kubernetes 1.24 wurde die spezielle Integration von Docker (`dockershim`), die als Container-Laufzeit verwendet werden konnte, aus Kubernetes entfernt. Sie können Docker zwar weiterhin zum Testen und Ausführen von Containern auf Ihrem lokalen System verwenden, aber um Docker mit Kubernetes zu verwenden, müssen Sie jetzt [Docker Engine auf jedem Knoten installieren](https://docs.docker.com/engine/install/#server), um es mit Kubernetes zu verwenden.
+ **Netzwerk zwischen Containern verwalten (`kube-proxy`)** – Um die Kommunikation zwischen Pods zu unterstützen, verwendet Kubernetes eine als [Service](https://kubernetes.io/docs/concepts/services-networking/service/) bezeichnetes Feature zum Einrichten von Pod-Netzwerken, welche die mit diesen Pods verknüpften IP-Adressen und Ports verfolgen. Der Service [kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/) wird in jedem Knoten ausgeführt, damit die Kommunikation zwischen Pods stattfinden kann.
### Cluster erweitern
Es gibt einige Services, die Sie zu Kubernetes hinzufügen können, um den Cluster zu unterstützen, die aber nicht in der Steuerebene ausgeführt werden. Diese Services werden oft direkt in Knoten im kube-system-Namespace oder in einem eigenen Namespace ausgeführt (wie dies bei Drittanbietern oft der Fall ist). Ein gängiges Beispiel ist der CoreDNS-Service, der DNS-Services für den Cluster bereitstellt. Informationen dazu, wie Sie feststellen können, welche Cluster-Services in Ihrem Cluster im Kube-System ausgeführt werden, finden Sie unter [Integrierte Services ermitteln](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster-services/).
Es gibt verschiedene Arten von Add-Ons, die Sie Ihren Clustern hinzufügen können. Um die Funktionsfähigkeit Ihrer Cluster zu gewährleisten, können Sie Beobachtbarkeitsfunktionen hinzufügen (siehe [Überwachung der Cluster-Leistung und Anzeige von Protokollen](eks-observe.md)), mit denen Sie beispielsweise Protokollierung, Überwachung und Metriken durchführen können. Mit diesen Informationen können Sie auftretende Probleme beheben, oft über dieselben Beobachtbarkeitsschnittstellen. Beispiele für diese Art von Services sind [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/runtime-monitoring.html) CloudWatch (siehe [Überwachen Sie Clusterdaten mit Amazon CloudWatch](cloudwatch.md)), [AWS Distro for OpenTelemetry](https://aws-otel.github.io/), Amazon VPC CNI Plugin für Kubernetes (siehe [Pods mit dem Amazon VPC CNI zuweisen IPs](managing-vpc-cni.md)) und [Grafana Kubernetes Monitoring](https://grafana.com/docs/grafana-cloud/monitor-infrastructure/kubernetes-monitoring/configuration/config-aws-eks/). Zu den Add-Ons für Amazon EKS im Bereich Speicher (siehe [Verwendung von Anwendungsdatenspeichern für Ihren Cluster](storage.md)) gehören Amazon Elastic Block Store CSI Driver (siehe [Kubernetes-Volume-Speicher mit Amazon EBS verwenden](ebs-csi.md)), Amazon Elastic File System CSI Driver (siehe [Verwendung von elastischem Dateisystemspeicher mit Amazon EFS](efs-csi.md)) und mehrere Speicher-Add-Ons von Drittanbietern wie Amazon FSx für NetApp-ONTAP-CSI-Treiber [Verwendung von leistungsstarkem App-Speicher mit FSx für NetApp ONTAP](fsx-ontap.md).
Eine umfassendere Liste der verfügbaren Amazon-EKS-Add-Ons finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md).
## Workloads
Kubernetes definiert einen [Workload](https://kubernetes.io/docs/concepts/workloads/) als „eine in Kubernetes ausgeführte Anwendung“. Diese Anwendung kann aus einer Reihe von Microservices bestehen, die als [Container](https://kubernetes.io/docs/reference/glossary/?fundamental=true#term-container) in [Pods](https://kubernetes.io/docs/reference/glossary/?fundamental=true#term-pod) ausgeführt werden, oder als Batch-Auftrag oder als eine andere Art von Anwendung. Kubernetes stellt sicher, dass Ihre Anforderungen für die Einrichtung oder Bereitstellung dieser Objekte ausgeführt werden. Als jemand, der Anwendungen bereitstellt, sollten Sie lernen, wie Container erstellt werden, wie Pods definiert werden und welche Methoden Sie für deren Bereitstellung verwenden können.
### Container
Das grundlegendste Element eines Anwendungs-Workloads, den Sie in Kubernetes bereitstellen und verwalten, ist ein * [Pod](https://kubernetes.io/docs/concepts/workloads/pods/) *. Ein Pod stellt eine Möglichkeit dar, die Komponenten einer Anwendung zu speichern und Spezifikationen zu definieren, die die Attribute des Pods beschreiben. Im Gegensatz dazu bietet beispielsweise ein RPM- oder Deb-Paket Software für ein Linux-System, das selbst jedoch nicht als Einheit ausgeführt wird.
Da der Pod die kleinste bereitstellbare Einheit ist, enthält er in der Regel einen einzigen Container. In Fällen, in denen Container eng miteinander verbunden sind, können sich jedoch mehrere Container in einem Pod befinden. Ein Webserver-Container kann beispielsweise in einem Pod mit einem [Sidecar](https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/)-Container verpackt sein, der die Protokollierung, Überwachung oder einen anderen Service bereitstellt, der eng mit dem Webserver-Container verbunden ist. In diesem Fall wird durch die Zugehörigkeit zum selben Pod sichergestellt, dass für jede ausgeführte Instance des Pods beide Container immer auf demselben Knoten ausgeführt werden. Ebenso teilen sich alle Container in einem Pod die gleiche Umgebung, wobei die Container in einem Pod so ausgeführt werden, als würden sie sich in demselben isolierten Host befinden. Dies hat zur Folge, dass die Container eine einzige IP-Adresse gemeinsam nutzen, die Zugriff auf den Pod bietet, und die Container miteinander kommunizieren können, als würden sie auf ihrem eigenen lokalen Host ausgeführt.
Pod-Spezifikationen ([PodSpec](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#PodSpec)) definieren den gewünschten Zustand des Pods. Sie können einen einzelnen Pod oder mehrere Pods bereitstellen, indem Sie Workload-Ressourcen zur Verwaltung von [Pod-Vorlagen](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates) verwenden. Zu den Workload-Ressourcen gehören [Bereitstellungen](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) (zum Verwalten mehrerer Pod-Replikate), [StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) (zum Bereitstellen von Pods, die eindeutig sein müssen, z. B. Datenbank-Pods) und [DaemonSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) (wobei ein Pod kontinuierlich auf jedem Knoten ausgeführt werden muss). Dazu später mehr.
Während ein Pod die kleinste Einheit ist, die Sie bereitstellen, ist ein Container die kleinste Einheit, die Sie entwickeln und verwalten.
#### Entwicklung von Containern
Der Pod ist eigentlich nur eine Struktur um einen oder mehrere Container, wobei jeder Container selbst das Dateisystem, ausführbare Dateien, Konfigurationsdateien, Bibliotheken und andere Komponenten enthält, um die Anwendung tatsächlich auszuführen. Da Container erstmals von einem Unternehmen namens Docker Inc. eingeführt wurden, werden sie manchmal als Docker-Container bezeichnet. Inzwischen hat die [Open Container Initiative](https://opencontainers.org/) seitdem Container-Laufzeiten, Images und Verteilungsmethoden für die Branche definiert. Hinzu kommt, dass Container aus vielen vorhandenen Linux-Features erstellt wurden. Andere bezeichnen Container oft als OCI-Container, Linux-Container oder einfach nur als Container.
Wenn Sie einen Container entwickeln, beginnen Sie in der Regel mit einer Docker-Datei (die wörtlich so heißt). Innerhalb dieser Docker-Datei identifizieren Sie:
+ **Ein Basis-Image** – Ein Basis-Container-Image ist ein Container, der normalerweise entweder aus einer Minimalversion des Dateisystems eines Betriebssystems (wie [Red Hat Enterprise Linux](https://catalog.redhat.com/software/base-images) oder [Ubuntu](https://gallery.ecr.aws/docker/library/ubuntu)) oder einem Minimalsystem erstellt wird, das erweitert wurde, um Software zum Ausführen bestimmter Arten von Anwendungen bereitzustellen (wie [Node.js](https://catalog.redhat.com/software/container-stacks/detail/611c11fabd674341b5c5ed64)- oder [Python](https://gallery.ecr.aws/docker/library/python)-Apps).
+ **Anwendungssoftware** – Sie können Ihre Anwendungssoftware Ihrem Container auf die gleiche Weise hinzufügen, wie Sie sie einem Linux-System hinzufügen würden. Beispielsweise können Sie in Ihrer Docker-Datei `npm` und `yarn` ausführen, um eine Java-Anwendung zu installieren, oder `yum` und `dnf`, um RPM-Pakete zu installieren. Anders ausgedrückt: Mit einem RUN-Befehl in einer Dockerdatei können Sie jeden Befehl ausführen, der im Dateisystem Ihres Basis-Images verfügbar ist, um Software zu installieren oder innerhalb des resultierenden Container-Images zu konfigurieren.
+ **Anweisungen** – Die [Dockerfile-Referenz](https://docs.docker.com/reference/dockerfile/) beschreibt die Anweisungen, die Sie einer Docker-Datei hinzufügen können, wenn Sie es konfigurieren. Dazu gehören Anweisungen zum Erstellen des Inhalts des Containers selbst (`ADD` oder `COPY`-Dateien aus dem lokalen System), zum Identifizieren von Befehlen, die beim Ausführen des Containers ausgeführt werden sollen (`CMD` oder `ENTRYPOINT`), und zum Verbinden des Containers mit dem System, in dem er ausgeführt wird (durch Identifizieren des auszuführenden `USER`, eines einzubindenden lokalen `VOLUME` oder der Ports zu `EXPOSE`).
Während der `docker`-Befehl und der Service üblicherweise zur Erstellung von Containern verwendet werden (`docker build`), gibt es auch andere Tools wie [podman](https://docs.podman.io/en/stable/markdown/podman-build.1.html) und [nerdctl](https://github.com/containerd/nerdctl), die zur Erstellung von Container-Images verwendet werden können. Weitere Informationen zur Erstellung von Containern finden Sie unter [Entwicklung besserer Container-Images](https://aws.amazon.com/blogs/containers/building-better-container-images) oder [Überblick über Docker Build](https://docs.docker.com/build/).
#### Aufbewahrungscontainer
Sobald Sie Ihr Container-Image entwickelt haben, können Sie es in einer [Registry für die Container-Verteilung](https://distribution.github.io/distribution/) in Ihrer Workstation oder in einer öffentlichen Container-Registry speichern. Durch die Ausführung einer privaten Container-Registry in Ihrer Workstation können Sie Container-Images lokal speichern und haben so jederzeit Zugriff darauf.
Um Container-Images auf eine öffentlichere Art und Weise zu speichern, können Sie sie in eine öffentliche Container-Registry verschieben. Öffentliche Container-Registries bieten einen zentralen Ort zum Speichern und Verteilen von Container-Images. Beispiele für öffentliche Container-Registrys sind die [Amazon Elastic Container Registry](https://aws.amazon.com/ecr/), [Red Hat Quay](https://quay.io/) Registry und [Docker Hub](https://hub.docker.com/) Registry.
Bei Ausführung von containerisierten Workloads in Amazon Elastic Kubernetes Service (Amazon EKS) empfehlen wir, Kopien der offiziellen Docker-Images abzurufen, die in der Amazon Elastic Container Registry gespeichert sind. Amazon ECR speichert diese Images seit 2021. Sie können in der [Amazon ECR Public Gallery](https://gallery.ecr.aws/) nach beliebten Container-Images suchen, und speziell nach den Docker-Hub-Images in der [Amazon ECR Docker Gallery](https://gallery.ecr.aws/docker/) suchen.
#### Ausführung von Containern
Da Container in einem Standardformat entwickelt werden, kann ein Container auf jedem Rechner ausgeführt werden, auf dem eine Container-Laufzeitumgebung (wie Docker) ausgeführt werden kann und dessen Inhalt der Architektur des lokalen Rechners entspricht (z. B. `x86_64` oder `arm`). Um einen Container zu testen oder ihn einfach auf Ihrem lokalen Desktop auszuführen, können Sie die Befehle `docker run` oder `podman run` verwenden, um einen Container auf dem lokalen Host zu starten. Bei Kubernetes hingegen ist auf jedem Worker-Knoten eine Container-Laufzeitumgebung bereitgestellt und es liegt an Kubernetes, einen Knoten aufzufordern, einen Container auszuführen.
Sobald ein Container zur Ausführung auf einem Knoten zugewiesen wurde, prüft der Knoten, ob die angeforderte Version des Container-Images bereits auf dem Knoten vorhanden ist. Ist dies nicht der Fall, weist Kubernetes die Container-Laufzeitumgebung an, den Container aus der entsprechenden Container-Registry abzurufen und ihn dann lokal auszuführen. Beachten Sie, dass sich ein *Container-Image* auf das Softwarepaket bezieht, das zwischen Ihrem Laptop, der Container-Registry und den Kubernetes-Knoten verschoben wird. Ein *Container* bezieht sich auf eine ausgeführte Instance dieses Images.
### Pods
Sobald Ihre Container bereit sind, umfasst die Arbeit mit Pods das Konfigurieren, Bereitstellen und Zugänglichmachen der Pods.
#### Konfigurierung von Pods
Wenn Sie einen Pod definieren, weisen Sie ihm eine Reihe von Attributen zu. Diese Attribute müssen mindestens den Pod-Namen und das auszuführende Container-Image enthalten. Es gibt jedoch noch viele weitere Dinge, die Sie mit Ihren Pod-Definitionen konfigurieren möchten (Details dazu, was in einen Pod aufgenommen werden kann, finden Sie auf der Seite [PodSpec](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#PodSpec)). Dazu zählen:
+ **Speicher** – Wenn ein ausgeführter Container angehalten und gelöscht wird, verschwindet der Datenspeicher in diesem Container, sofern Sie keinen dauerhafteren Speicher einrichten. Kubernetes unterstützt viele verschiedene Speicher und fasst diese unter dem Begriff [Volumes](https://kubernetes.io/docs/concepts/storage/volumes/) zusammen. Zu den Speichertypen gehören [CephFS](https://kubernetes.io/docs/concepts/storage/volumes/#cephfs), [NFS](https://kubernetes.io/docs/concepts/storage/volumes/#nfs), [iSCSI](https://kubernetes.io/docs/concepts/storage/volumes/#iscsi) und andere. Sie können sogar ein [lokales Blockgerät](https://kubernetes.io/docs/concepts/storage/volumes/#local) vom lokalen Computer aus verwenden. Mit einem dieser in Ihrem Cluster verfügbaren Speichertypen können Sie das Speichervolume an einem ausgewählten Einbindepunkt im Dateisystem Ihres Containers einbinden. Ein [persistentes Volume](https://kubernetes.io/docs/concepts/storage/persistent-volumes/) ist ein Volume, das nach dem Löschen des Pods weiterhin vorhanden ist, während ein [flüchtiges Volume](https://kubernetes.io/docs/concepts/storage/ephemeral-volumes/) gelöscht wird, wenn der Pod gelöscht wird. Wenn Ihr Cluster-Administrator verschiedene [Speicherklassen](https://kubernetes.io/docs/concepts/storage/storage-classes/) für Ihren Cluster erstellt hat, haben Sie möglicherweise die Möglichkeit, die Attribute des von Ihnen verwendeten Speichers auszuwählen, z. B. ob das Volume nach der Verwendung gelöscht oder wiederhergestellt wird, ob es erweitert wird, wenn mehr Speicherplatz benötigt wird, und sogar, ob es bestimmte Leistungsanforderungen erfüllt
+ **Geheimnisse** – Indem Sie Containern in Pod-Spezifikationen [Geheimnisse](https://kubernetes.io/docs/concepts/configuration/secret/) zur Verfügung stellen, können Sie diesen Containern die Berechtigungen gewähren, die sie für den Zugriff auf Dateisysteme, Datenbanken oder andere geschützte Komponenten benötigen. Schlüssel, Passwörter und Token gehören zu den Elementen, die als Geheimnisse gespeichert werden können. Durch die Verwendung von Geheimnissen müssen Sie diese Informationen nicht in Container-Images speichern, sondern müssen sie nur ausgeführten Containern zur Verfügung stellen. Ähnlich wie Geheimnisse sind [ConfigMaps](https://kubernetes.io/docs/concepts/configuration/configmap/). Ein `ConfigMap` enthält in der Regel weniger kritische Informationen, wie beispielsweise Schlüssel-Wert-Paare zur Konfiguration eines Service.
+ **Container-Ressourcen** – Objekte zur weiteren Konfiguration von Containern können in Form von Ressourcenkonfigurationen vorliegen. Sie können für jeden Container die Speicher- und CPU-Menge anfordern, die er verwenden kann, und auch Beschränkungen für die Gesamtmenge dieser Ressourcen festlegen, die der Container verwenden kann. Beispiele finden Sie unter [Ressource-Verwaltung für Pods und Container](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/).
+ **Störungen** – Pods können unfreiwillig (wenn ein Knoten ausfällt) oder freiwillig (wenn ein Upgrade gewünscht wird) unterbrochen werden. Durch die Konfiguration eines [Budgets für Pod-Unterbrechungen](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/#pod-disruption-budgets) können Sie eine gewisse Kontrolle darüber ausüben, wie verfügbar Ihre Anwendung bleibt, wenn Störungen auftreten. Beispiele finden Sie unter [Festlegen eines Budgets für Unterbrechung](https://kubernetes.io/docs/tasks/run-application/configure-pdb/) für Ihre Anwendung.
+ **Namespaces** – Kubernetes bietet verschiedene Möglichkeiten, Kubernetes-Komponenten und -Workloads voneinander zu isolieren. Das Ausführen aller Pods für eine bestimmte Anwendung im selben [Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) ist eine gängige Methode, um diese Pods gemeinsam zu sichern und zu verwalten. Sie können Ihre eigenen Namespaces erstellen oder keinen Namespace angeben (was dazu führt, dass Kubernetes den `default`-Namespace verwendet). Die Komponenten der Kubernetes-Steuerebene werden in der Regel im Namespace [kube-system](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) ausgeführt.
Die soeben beschriebene Konfiguration wird in der Regel in einer YAML-Datei zusammengefasst, die auf den Kubernetes-Cluster angewendet wird. Für persönliche Kubernetes-Cluster können Sie diese YAML-Dateien einfach auf Ihrem lokalen System speichern. Bei kritischeren Clustern und Workloads ist [GitOps](https://www.eksworkshop.com/docs/automation/gitops/) jedoch eine beliebte Methode, um sowohl den Speicher als auch die Aktualisierung von Workloads- und Kubernetes-Infrastrukturressourcen zu automatisieren.
Die zum Erfassen und Bereitstellen von Pod-Informationen verwendeten Objekte werden durch eine der folgenden Bereitstellungsmethoden definiert.
#### Bereitstellen von Pods
Die Methode, die Sie zum Bereitstellen von Pods wählen, hängt von der Art der Anwendung ab, die Sie mit diesen Pods ausführen möchten. Hier finden Sie einige Optionen:
+ **Zustandslose Anwendungen** – Eine zustandslose Anwendung speichert die Sitzungsdaten eines Clients nicht, sodass eine andere Sitzung nicht auf die Vorgänge einer vorherigen Sitzung zurückgreifen muss. Dies vereinfacht das Ersetzen von Pods durch neue, wenn sie fehlerhaft werden, oder das Verschieben ohne Speicherung des Zustands. Wenn Sie eine zustandslose Anwendung (z. B. einen Webserver) ausführen, können Sie eine [Bereitstellung](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) verwenden, um [Pods](https://kubernetes.io/docs/concepts/workloads/pods/) und [ReplicaSets](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) bereitzustellen. Ein ReplicaSet legt fest, wie viele Instances eines Pods gleichzeitig ausgeführt werden sollen. Obwohl Sie ein ReplicaSet direkt ausführen können, ist es üblich, Replikate direkt innerhalb einer Bereitstellung auszuführen, um zu definieren, wie viele Replikate eines Pods gleichzeitig ausgeführt werden sollen.
+ **Zustandsbehaftete Anwendungen** – Bei einer zustandsbehafteten Anwendung sind die Identität des Pods und die Reihenfolge, in der die Pods gestartet werden, wichtig. Diese Anwendungen benötigen einen stabilen persistenten Speicher und müssen auf konsistente Weise bereitgestellt und skaliert werden. Um eine zustandsbehaftete Anwendung in Kubernetes bereitzustellen, können Sie [StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) verwenden. Ein Beispiel für eine Anwendung, die typischerweise als StatefulSet ausgeführt wird, ist eine Datenbank. Innerhalb eines StatefulSet können Sie Replikate, den Pod und seine Container, einzubindende Speicher sowie Standorte im Container definieren, an denen Daten gespeichert werden. Ein Beispiel für eine Datenbank, die als ReplicaSet bereitgestellt wird, finden Sie unter [Ausführen einer replizierten zustandsbehafteten Anwendung](https://kubernetes.io/docs/tasks/run-application/run-replicated-stateful-application/).
+ **Anwendungen pro Knoten** – Es kann vorkommen, dass Sie eine Anwendung auf jedem Knoten in Ihrem Kubernetes-Cluster ausführen möchten. Beispielsweise könnte Ihr Rechenzentrum die Ausführung einer Überwachungsanwendung oder eines bestimmten Fernzugriffs auf jedem Computer verlangen. Für Kubernetes können Sie [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/) verwenden, um sicherzustellen, dass die ausgewählte Anwendung auf jedem Knoten in Ihrem Cluster ausgeführt wird.
+ **Anwendungen werden vollständig ausgeführt** – Es gibt einige Anwendungen, die Sie ausführen möchten, um eine bestimmte Aufgabe abzuschließen. Dazu könnten beispielsweise Anwendungen gehören, die monatliche Statusberichte erstellen oder alte Daten bereinigen. Mit einem Objekt vom Typ [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/) kann eine Anwendung so eingerichtet werden, dass sie gestartet und ausgeführt wird und nach Abschluss der Aufgabe beendet wird. Mit einem Objekt vom Typ [CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/) können Sie eine Anwendung so einrichten, dass sie zu einer bestimmten Stunde, Minute, an einem bestimmten Tag im Monat, Monat oder Wochentag ausgeführt wird. Dabei wird eine Struktur verwendet, die durch das Linux-Format [crontab](https://man7.org/linux/man-pages/man5/crontab.5.html) definiert ist.
#### Anwendungen über das Netzwerk zugänglich machen
Da Anwendungen häufig als eine Reihe von Microservices bereitgestellt werden, die an verschiedene Orte verschoben werden, benötigte Kubernetes eine Möglichkeit, damit diese Microservices einander finden können. Damit andere auf eine Anwendung außerhalb des Kubernetes-Clusters zugreifen können, benötigte Kubernetes außerdem eine Möglichkeit, diese Anwendung über externe Adressen und Ports verfügbar zu machen. Diese netzwerkbezogenen Features werden mit Service- und Ingress-Objekten durchgeführt:
+ **Services** – Da sich ein Pod zu verschiedenen Knoten und Adressen bewegen kann, kann es für einen anderen Pod, der mit dem ersten Pod kommunizieren muss, schwierig sein, dessen Standort zu ermitteln. Um dieses Problem zu lösen, ermöglicht Kubernetes die Darstellung einer Anwendung als [Service](https://kubernetes.io/docs/concepts/services-networking/service/). Mit einem Service können Sie einen Pod oder eine Gruppe von Pods mit einem bestimmten Namen identifizieren und dann angeben, welcher Port den Service dieser Anwendung vom Pod aus verfügbar macht und welche Ports eine andere Anwendung verwenden könnte, um diesen Service zu kontaktieren. Ein anderer Pod innerhalb eines Clusters kann einfach einen Service nach Namen anfordern und Kubernetes leitet diese Anforderung an den richtigen Port für eine Instance des Pods weiter, auf dem dieser Service ausgeführt wird.
+ **Ingress** – [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) ermöglicht es, Anwendungen, die durch Kubernetes-Services dargestellt werden, für Clients außerhalb des Clusters verfügbar zu machen. Zu den grundlegenden Features von Ingress gehören ein Load Balancer (verwaltet von Ingress), der Ingress-Controller und Regeln für die Weiterleitung von Anfragen vom Controller an den Service. Es gibt mehrere [Ingress-Controller](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/), aus denen Sie mit Kubernetes auswählen können.
## Nächste Schritte
Das Verständnis der grundlegenden Kubernetes-Konzepte und ihrer Beziehung zu Amazon EKS wird Ihnen dabei helfen, sowohl die [Amazon-EKS-Dokumentation](https://docs.aws.amazon.com/eks/) als auch die [Kubernetes-Dokumentation](https://kubernetes.io/docs) zu durchsuchen, um die Information zu finden, die Sie für die Verwaltung von Amazon-EKS-Clustern und das Bereitstellen von Workloads in diesen Clustern benötigen. Um mit der Nutzung von Amazon EKS zu beginnen, wählen Sie eine der folgenden Optionen aus:
+ [Erste Schritte mit Amazon EKS – `eksctl`](getting-started-eksctl.md)
+ [Amazon-EKS-Cluster erstellen](create-cluster.md)
+ [Eine Beispielanwendung in Linux bereitstellen](sample-deployment.md)
+ [Organisieren und Überwachen von Cluster-Ressourcen](eks-managing.md)
# Bereitstellung von Amazon-EKS-Clustern in Cloud- und On-Premises-Umgebungen
## Bereitstellungsoptionen von Amazon EKS kennenlernen
Amazon Elastic Kubernetes Service (Amazon EKS) ist ein vollständig verwalteter Kubernetes- Service, mit dem Sie Kubernetes nahtlos in der Cloud und in Ihren On-Premises-Umgebungen ausführen können.
In der Cloud automatisiert Amazon EKS die Verwaltung der Kubernetes-Cluster-Infrastruktur für die Kubernetes-Steuerebene und die Knoten. Dies ist für die Planung von Containern, die Verwaltung der Anwendungsverfügbarkeit, die dynamische Skalierung von Ressourcen, die Optimierung der Rechenleistung, die Speicherung von Cluster-Daten und die Ausführung anderer wichtiger Funktionen unerlässlich. Mit Amazon EKS profitieren Sie von einer stabilen Leistung, Skalierbarkeit, Zuverlässigkeit und Verfügbarkeit der AWS-Infrastruktur sowie von nativen Integrationen mit AWS-Netzwerk-, Sicherheits-, Speicher- und Beobachtbarkeitsservices.
Um die Ausführung von Kubernetes in Ihren On-Premises-Umgebungen zu vereinfachen, können Sie dieselben Amazon-EKS-Cluster, -Features und -Tools für [Amazon Linux-Knoten auf AWS Outposts erstellen](eks-outposts-self-managed-nodes.md) oder [Amazon EKS Hybrid Nodes](hybrid-nodes-overview.md) in Ihrer eigenen Infrastruktur verwenden oder [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/) für eigenständige Air-Gap-Umgebungen verwenden.
## Amazon EKS in der Cloud
Sie können Amazon EKS mit Rechenleistung in AWS-Regionen, AWS Local Zones und AWS Wavelength Zones nutzen. Mit Amazon EKS in der Cloud werden die Sicherheit, Skalierbarkeit und Verfügbarkeit der Kubernetes- Steuerebene vollständig von AWS in der AWS-Region verwaltet. Wenn Sie Anwendungen mit Rechenleistung in AWS-Regionen ausführen, können Sie die gesamte Bandbreite von AWS- und Amazon-EKS-Features nutzen, einschließlich Amazon EKS Auto Mode, der die Verwaltung der Kubernetes-Cluster-Infrastruktur für Rechenleistung, Speicher und Netzwerk in AWS mit einem einzigen Klick vollständig automatisiert. Wenn Sie Anwendungen mit Rechenleistung in AWS Local Zones und AWS Wavelength Zones ausführen, können Sie selbstverwaltete Amazon-EKS-Knoten verwenden, um Amazon-EC2-Instances für Ihre Cluster-Rechenleistung zu verbinden. Außerdem können Sie die anderen verfügbaren AWS-Services in AWS Local Zones und AWS Wavelength Zones nutzen. Weitere Informationen finden Sie unter [Features für AWS Local Zones](https://aws.amazon.com/about-aws/global-infrastructure/localzones/features/) und [Features für AWS Wavelength Zones](https://aws.amazon.com/wavelength/features/).
| | Amazon EKS in AWS-Regionen | Amazon EKS in Local/Wavelength Zones |
| --- | --- | --- |
| Verwaltung der Kubernetes-Steuerebene | AWS-verwaltet | AWS-verwaltet |
| Ort der Kubernetes-Steuerebene | AWS-Regionen | AWS-Regionen |
| Kubernetes-Datenebene | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/eks-deployment-options.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/eks-deployment-options.html) |
| Ort der Kubernetes-Datenebene | AWS-Regionen | AWS Local or Wavelength Zones |
## Amazon EKS in Ihrem Rechenzentrum oder in Ihren Edge-Umgebungen
Wenn Sie Anwendungen in Ihren eigenen Rechenzentren oder Edge-Umgebungen ausführen müssen, können Sie [Bereitstellung von Amazon EKS On-Premises mit AWS Outposts](eks-outposts.md) oder [Amazon EKS Hybrid Nodes](hybrid-nodes-overview.md) verwenden. Sie können selbstverwaltete Knoten mit Amazon-EC2-Instances in AWS Outposts für Ihre Cluster-Berechnung verwenden oder Amazon EKS Hybrid Nodes mit Ihrer eigenen On-premises-oder Edge-Infrastruktur für Ihre Cluster-Berechnung verwenden. AWS Outposts ist eine von AWS verwaltete Infrastruktur, die Sie in Ihren Rechenzentren oder Co-Location-Einrichtungen betreiben, während Amazon EKS Hybrid Nodes auf Ihren physischen oder virtuellen Rechnern ausgeführt wird, die Sie in Ihren On-Premises- oder Edge-Umgebungen verwalten. Amazon EKS in AWS Outposts und Amazon EKS Hybrid Nodes erfordern eine zuverlässige Verbindung von Ihren On-Premises-Umgebungen zu einer AWS-Region. Sie können dieselben Amazon-EKS-Cluster, -Feature und -Tools verwenden, die Sie auch für die Ausführung von Anwendungen in der Cloud einsetzen. Bei der Ausführung in AWS Outposts besteht die Möglichkeit, den gesamten Kubernetes-Cluster in AWS Outposts mit lokalen Amazon-EKS-Clustern in AWS Outposts bereitzustellen.
| | Amazon EKS Hybrid Nodes | Amazon EKS in AWS Outposts |
| --- | --- | --- |
| Verwaltung der Kubernetes-Steuerebene | AWS-verwaltet | AWS-verwaltet |
| Ort der Kubernetes-Steuerebene | AWS-Regionen | AWS Regions oder AWS Outposts |
| Kubernetes-Datenebene | Vom Kunden verwaltete physische oder virtuelle Rechner | Selbstverwaltete Amazon-EC2-Knoten |
| Ort der Kubernetes-Datenebene | Rechenzentrum oder Edge-Umgebung des Kunden | Rechenzentrum oder Edge-Umgebung des Kunden |
## Amazon EKS Anywhere für Air-Gapped-Umgebungen
[Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/) vereinfacht die Verwaltung von Kubernetes-Clustern durch die Automatisierung undifferenzierter, aufwändiger Aufgaben wie der Einrichtung der Infrastruktur und der Verwaltung des Lebenszyklus von Kubernetes-Clustern in On-Premises- und Edge-Umgebungen. Im Gegensatz zu Amazon EKS ist Amazon EKS Anywhere ein vom Kunden verwaltetes Produkt, und die Kunden sind für den Lebenszyklusvorgang und die Wartung von Amazon-EKS-Anywhere-Clustern verantwortlich. Amazon EKS Anywhere basiert auf dem Kubernetes-Nebenprojekt Cluster API (CAPI) und unterstützt eine Reihe von Infrastrukturen, darunter VMware vSphere, Bare Metal, Nutanix, Apache CloudStack und AWS Snow. Amazon EKS Anywhere kann in Air-Gapped-Umgebungen ausgeführt werden und bietet optionale Integrationen mit regionalen AWS-Services für Beobachtbarkeit und Identitätsmanagement. Um Support für Amazon EKS Anywhere und Zugriff auf von AWS bereitgestellte Kubernetes-Add-Ons zu erhalten, können Sie [Abonnements für Amazon EKS Anywhere Enterprise](https://aws.amazon.com/eks/eks-anywhere/pricing/) erwerben.
| | Amazon EKS Anywhere |
| --- | --- |
| Verwaltung der Kubernetes-Steuerebene | Vom Kunden verwaltet |
| Ort der Kubernetes-Steuerebene | Rechenzentrum oder Edge-Umgebung des Kunden |
| Kubernetes-Datenebene | Vom Kunden verwaltete physische oder virtuelle Rechner |
| Ort der Kubernetes-Datenebene | Rechenzentrum oder Edge-Umgebung des Kunden |
## Amazon-EKS-Tools
Mit dem [Amazon EKS Connector](eks-connector.md) können Sie jeden konformen Kubernetes-Cluster bei AWS registrieren und verbinden und ihn in der Amazon-EKS-Konsole anzeigen. Nachdem ein Cluster verbunden wurde, können Sie den Status, die Konfiguration und die Workloads für diesen Cluster in der Amazon-EKS-Konsole anzeigen. Mit diesem Feature können Sie verbundene Cluster in der Amazon-EKS-Konsole anzeigen, jedoch ermöglicht Amazon EKS Connector keine Verwaltungs- oder Änderungsvorgänge für Ihre verbundenen Cluster über die Amazon-EKS-Konsole.
[Amazon EKS Distro](https://aws.amazon.com/eks/eks-distro/) ist die AWS-Verteilung der zugrunde liegenden Kubernetes-Komponenten, die alle Amazon-EKS-Angebote unterstützen. Es enthält die Kernkomponenten, die für einen funktionierenden Kubernetes-Cluster erforderlich sind, wie z. B. Kubernetes-Steuerebenen-Komponenten (etcd, Kube-API-Server, Kube-Scheduler, Kube-Controller-Manager) und Netzwerkkomponenten (CoreDNS, Kube-Proxy, CNI-Plugins). Amazon EKS Distro kann zur Selbstverwaltung von Kubernetes-Clustern mit den Tools Ihrer Wahl verwendet werden. Bereitstellungen für Amazon EKS Distro sind nicht durch AWS-Support-Pläne abgedeckt.