**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.
# Zusammenstellung von Ressourcen mit kro (Kube Resource Orchestrator)
**kro (Kube Resource Orchestrator)** ist ein Kubernetes-natives Open-Source-Projekt, mit dem Sie benutzerdefinierte Kubernetes mithilfe einer einfachen und unkomplizierten Konfiguration definieren können. APIs Mit kro können Sie ganz einfach neue benutzerdefinierte Objekte konfigurieren, die eine Gruppe von Kubernetes-Objekten und APIs die logischen Operationen zwischen ihnen erstellen.
Mit EKS Capabilities wird kro vollständig von verwaltet AWS, sodass Sie Kro-Controller nicht mehr auf Ihren Clustern installieren, warten und skalieren müssen.
## Wie funktioniert Kro
kro führt eine benutzerdefinierte Ressourcendefinition (CRD) namens `ResourceGraphDefinition` (RGD) ein, die die einfache und optimierte Erstellung von benutzerdefinierten Kubernetes ermöglicht. APIs Wenn Sie eine erstellen, verwendet Kro native Kubernetes-Erweiterungen`ResourceGraphDefinition`, um neue in Ihrem Cluster zu erstellen und zu verwalten. APIs Auf der Grundlage dieser einzelnen Ressourcenspezifikation erstellt und registriert kro für Sie eine neue CRD auf der Grundlage Ihrer Spezifikation und passt sich an die Verwaltung Ihrer neu definierten benutzerdefinierten Ressourcen an.
RGDs kann mehrere Ressourcen beinhalten, und Kro bestimmt die gegenseitigen Abhängigkeiten und die Reihenfolge der Ressourcen, sodass Sie sich nicht darum kümmern müssen. Sie können eine einfache Syntax verwenden, um Konfigurationen von einer Ressource in eine andere zu übertragen, wodurch Kompositionen erheblich vereinfacht werden und die Notwendigkeit von „Glue“ -Operatoren in Ihrem Cluster entfällt. Mit kro können Ihre benutzerdefinierten Ressourcen sowohl native Kubernetes-Ressourcen als auch alle im Cluster installierten benutzerdefinierten Ressourcendefinitionen (CRDs) enthalten.
kro unterstützt einen einzigen primären Ressourcentyp:
+ **ResourceGraphDefinition (RGD)**: Definiert eine benutzerdefinierte Kubernetes-Ressource, die eine oder mehrere zugrunde liegende native oder benutzerdefinierte Kubernetes-Ressourcen kapselt
Zusätzlich zu dieser Ressource erstellt und verwaltet kro den Lebenszyklus Ihrer damit erstellten benutzerdefinierten Ressourcen sowie aller zugehörigen Ressourcen.
kro lässt sich nahtlos in AWS Controllers for Kubernetes (ACK) integrieren, sodass Sie Workload-Ressourcen mit AWS Ressourcen zusammenstellen können, um Abstraktionen auf höherer Ebene zu erstellen. Auf diese Weise können Sie Ihre eigenen Cloud-Bausteine erstellen, das Ressourcenmanagement vereinfachen und wiederverwendbare Muster mit standardmäßigen und unveränderlichen Konfigurationseinstellungen ermöglichen, die auf Ihren Unternehmensstandards basieren.
## Vorteile von Kro
kro ermöglicht es Plattformteams, benutzerdefinierte Kubernetes zu erstellen, APIs die mehrere Ressourcen zu Abstraktionen auf höherer Ebene zusammensetzen. Dies vereinfacht das Ressourcenmanagement, da Entwickler komplexe Anwendungen mithilfe einfacher, standardisierter und versionierter benutzerdefinierter Ressourcen bereitstellen können. Sie definieren wiederverwendbare Muster für gängige Ressourcenkombinationen und ermöglichen so eine konsistente Ressourcenerstellung in Ihrer gesamten Organisation.
kro verwendet [Common Expression Language (CEL) in Kubernetes](https://kubernetes.io/docs/reference/using-api/cel/), um Werte zwischen Ressourcen zu übergeben und bedingte Logik zu integrieren, was Flexibilität bei der Ressourcenzusammensetzung bietet. Sie können sowohl Kubernetes-Ressourcen als auch von ACK verwaltete Ressourcen zu einheitlichen benutzerdefinierten AWS Ressourcen zusammenfassen APIs, sodass vollständige Anwendungs- und Infrastrukturdefinitionen möglich sind.
kro unterstützt die deklarative Konfiguration über Kubernetes-Manifeste und ermöglicht so GitOps Workflows und Infrastruktur als Code-Praktiken, die sich nahtlos in Ihre bestehenden Entwicklungsprozesse integrieren lassen. Als Teil von EKS Managed Capabilities wird kro vollständig von verwaltet AWS, sodass Sie keine Kro-Controller auf Ihren Clustern installieren, konfigurieren und warten müssen.
**Beispiel: Erstellen eines ResourceGraphDefinition**
Das folgende Beispiel zeigt ein einfaches Beispiel`ResourceGraphDefinition`, das eine Webanwendung mit einem Deployment und einem Service erstellt:
```
apiVersion: kro.run/v1alpha1
kind: ResourceGraphDefinition
metadata:
name: web-application
spec:
schema:
apiVersion: v1alpha1
kind: WebApplication
spec:
name: string
replicas: integer | default=3
resources:
- id: deployment
template:
apiVersion: apps/v1
kind: Deployment
metadata:
name: ${schema.spec.name}
spec:
replicas: ${schema.spec.replicas}
- id: service
template:
apiVersion: v1
kind: Service
metadata:
name: ${schema.spec.name}
```
Wenn Benutzer Instanzen der `WebApplication` benutzerdefinierten Ressource erstellen, erstellt Kro automatisch die entsprechenden Bereitstellungs- und Dienstressourcen und verwaltet deren Lebenszyklus zusammen mit der benutzerdefinierten Ressource.
## Integration mit anderen von EKS verwalteten Funktionen
kro lässt sich in andere von EKS verwaltete Funktionen integrieren.
+ ** AWS Controller für Kubernetes (ACK)**: Verwenden Sie Kro, um ACK-Ressourcen in Abstraktionen auf höherer Ebene zusammenzustellen und so das Ressourcenmanagement zu vereinfachen. AWS
+ **Argo CD**: Verwenden Sie Argo CD, um die Bereitstellung von benutzerdefinierten Kro-Ressourcen in mehreren Clustern zu verwalten und so Workflows für Ihre Plattformbausteine und Anwendungsstapel zu ermöglichen GitOps .
## Erste Schritte mit Kro
Um mit der EKS-Funktion für kro zu beginnen:
1. [Erstellen Sie eine Kro-Capability-Ressource](create-kro-capability.md) auf Ihrem EKS-Cluster über die AWS Konsole, AWS CLI oder Ihr bevorzugtes Infrastructure-as-Code-Tool.
1. Create ResourceGraphDefinitions (RGDs), die Ihre benutzerdefinierte Zusammensetzung APIs und Ihre Ressourcenzusammensetzung definieren.
1. Wenden Sie Instanzen Ihrer benutzerdefinierten Ressourcen an, um die zugrunde liegenden Kubernetes und Ressourcen bereitzustellen und AWS zu verwalten.
# Eine Kro-Fähigkeit erstellen
In diesem Thema wird erklärt, wie Sie eine Kro-Funktion auf Ihrem Amazon EKS-Cluster erstellen.
## Voraussetzungen
Bevor Sie eine Kro-Fähigkeit erstellen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Ein vorhandener Amazon EKS-Cluster, auf dem eine unterstützte Kubernetes-Version ausgeführt wird (alle Versionen mit Standard- und erweitertem Support werden unterstützt)
+ Ausreichende IAM-Berechtigungen zum Erstellen von Funktionsressourcen auf EKS-Clustern
+ (Für CLI/eksCTL) Das entsprechende CLI-Tool wurde installiert und konfiguriert
**Anmerkung**
Im Gegensatz zu ACK und Argo CD benötigt kro keine zusätzlichen IAM-Berechtigungen, die über die Vertrauensrichtlinie hinausgehen. Kro arbeitet ausschließlich innerhalb Ihres Clusters und führt keine API-Aufrufe durch. AWS Sie müssen jedoch weiterhin eine IAM-Fähigkeitsrolle mit der entsprechenden Vertrauensrichtlinie bereitstellen. Informationen zur Konfiguration von Kubernetes-RBAC-Berechtigungen für Kro finden Sie unter. [Kro-Berechtigungen konfigurieren](kro-permissions.md)
## Wählen Sie Ihr Tool
Sie können eine Kro-Fähigkeit mit der AWS-Managementkonsole AWS CLI oder eksctl erstellen:
+ [Erstellen Sie mit der Konsole eine Kro-Fähigkeit](kro-create-console.md)- Verwenden Sie die Konsole für ein geführtes Erlebnis
+ [Erstellen Sie eine Kro-Fähigkeit mit der CLI AWS](kro-create-cli.md)- Verwenden Sie die AWS CLI für Scripting und Automatisierung
+ [Erstellen Sie eine Kro-Fähigkeit mit eksctl](kro-create-eksctl.md)- Verwenden Sie eksctl für ein Kubernetes-natives Erlebnis
## Was passiert, wenn Sie eine Kro-Fähigkeit erstellen
Wenn Sie eine Kro-Fähigkeit erstellen:
1. EKS erstellt den Kro-Capability Service und konfiguriert ihn für die Überwachung und Verwaltung der Ressourcen in Ihrem Cluster
1. Benutzerdefinierte Ressourcendefinitionen (CRDs) sind in Ihrem Cluster installiert
1. Für Ihre IAM-Capability Role wird automatisch ein Zugriffseintrag erstellt`AmazonEKSKROPolicy`, der Berechtigungen für die Verwaltung ResourceGraphDefinitions und die zugehörigen Instanzen gewährt (siehe[Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md))
1. Die Funktion übernimmt die von Ihnen angegebene IAM-Fähigkeitsrolle (wird nur für die Vertrauensbeziehung verwendet)
1. kro beginnt, nach `ResourceGraphDefinition` Ressourcen und ihren Instanzen Ausschau zu halten
1. Der Status der Fähigkeit ändert sich von zu `CREATING` `ACTIVE`
Sobald diese Option aktiviert ist, können Sie benutzerdefinierte Objekte erstellen, definieren APIs und Instanzen davon erstellen APIs. ResourceGraphDefinitions
**Anmerkung**
Der automatisch erstellte Zugriffseintrag beinhaltet den Eintrag`AmazonEKSKROPolicy`, der Kros Berechtigungen zur Verwaltung gewährt, ResourceGraphDefinitions und deren Instanzen. Damit Kro die zugrunde liegenden Kubernetes-Ressourcen, die in Ihren definiert sind ResourceGraphDefinitions (wie Deployments, Services oder ACK-Ressourcen), erstellen kann, müssen Sie zusätzliche Zugriffsrichtlinien konfigurieren. Weitere Informationen zu Zugriffseinträgen und zur Konfiguration zusätzlicher Berechtigungen finden Sie unter und. [Kro-Berechtigungen konfigurieren](kro-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Nächste Schritte
Nach der Erstellung der Kro-Fähigkeit:
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
+ [Kro-Konzepte](kro-concepts.md)- Erfahren Sie mehr über SimpleSchema CEL-Ausdrücke und Muster der Ressourcenzusammensetzung
# Erstellen Sie mit der Konsole eine Kro-Fähigkeit
In diesem Thema wird beschrieben, wie Sie eine Kro-Fähigkeit (Kube Resource Orchestrator) mithilfe von erstellen. AWS-Managementkonsole
## Erstellen Sie die Kro-Fähigkeit
1. Öffnen Sie die Amazon EKS-Konsole unter https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Wählen Sie Ihren Clusternamen aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Funktionen**.
1. Wählen Sie in der linken Navigationsleiste **kro (Kube Resource Orchestrator**) aus.
1. Wählen Sie Kro-Fähigkeit **erstellen** aus.
1. Für die Rolle „**IAM-Fähigkeit**“:
+ Wenn Sie bereits über eine IAM-Fähigkeitsrolle verfügen, wählen Sie sie aus der Dropdownliste aus
+ Wenn Sie eine Rolle erstellen müssen, wählen Sie **Create** kro role
Dadurch wird die IAM-Konsole auf einer neuen Registerkarte mit einer vorab ausgefüllten Vertrauensrichtlinie geöffnet. Für die Rolle sind keine zusätzlichen IAM-Berechtigungen erforderlich, da Kro vollständig in Ihrem Cluster ausgeführt wird.
Kehren Sie nach dem Erstellen der Rolle zur EKS-Konsole zurück. Die Rolle wird automatisch ausgewählt.
**Anmerkung**
Im Gegensatz zu ACK und Argo CD benötigt kro keine zusätzlichen IAM-Berechtigungen, die über die Vertrauensrichtlinie hinausgehen. Kro arbeitet ausschließlich innerhalb Ihres Clusters und führt keine API-Aufrufe durch. AWS
1. Wählen Sie **Erstellen** aus.
Der Prozess zur Schaffung von Fähigkeiten beginnt.
## Stellen Sie sicher, dass die Fähigkeit aktiv ist
1. Sehen Sie sich auf der Registerkarte **Funktionen** den Status der Kro-Fähigkeit an.
1. Warten Sie, bis sich der Status von `CREATING` zu `ACTIVE` ändert.
1. Sobald die Funktion aktiv ist, ist sie einsatzbereit.
Informationen zum Status der Funktionen und zur Problembehandlung finden Sie unter[Mit Capability-Ressourcen arbeiten](working-with-capabilities.md).
## Erteilen Sie Berechtigungen zur Verwaltung von Kubernetes-Ressourcen
Wenn Sie eine Kro-Funktion erstellen, wird automatisch ein EKS-Zugriffseintrag mit dem erstellt`AmazonEKSKROPolicy`, sodass Kro und ihre Instanzen verwalten ResourceGraphDefinitions können. Es werden jedoch standardmäßig keine Berechtigungen zum Erstellen der zugrunde liegenden Kubernetes-Ressourcen (wie Bereitstellungen, Dienste usw.) gewährt, die in ConfigMaps Ihrem definiert sind. ResourceGraphDefinitions
Dieses vorsätzliche Design folgt dem Prinzip der geringsten Rechte ResourceGraphDefinitions — unterschiedliche Rechte erfordern unterschiedliche Berechtigungen. Sie müssen die Berechtigungen, die kro benötigt, explizit auf der Grundlage der Ressourcen konfigurieren, die Sie verwalten werden. ResourceGraphDefinitions
Verwenden `AmazonEKSClusterAdminPolicy` Sie für einen schnellen Einstieg in Test- oder Entwicklungsumgebungen:
1. Navigieren Sie in der EKS-Konsole zur Registerkarte **Access** Ihres Clusters.
1. Suchen Sie unter **Access-Einträge** den Eintrag für Ihre Kro-Capability-Rolle (sie wird den Rollen-ARN haben, den Sie zuvor erstellt haben).
1. Wählen Sie den Access-Eintrag aus, um die zugehörigen Details zu öffnen.
1. Wählen Sie im Abschnitt **Zugriffsrichtlinien die** Option **Zugriffsrichtlinie zuordnen** aus.
1. Wählen Sie `AmazonEKSClusterAdminPolicy` aus der Richtlinienliste aus.
1. Wählen Sie als **Zugriffsbereich** die Option **Cluster** aus.
1. Wählen Sie **Associate** aus.
**Wichtig**
Das `AmazonEKSClusterAdminPolicy` gewährt umfassende Berechtigungen zum Erstellen und Verwalten aller Kubernetes-Ressourcen, einschließlich der Möglichkeit, beliebige Ressourcentypen in allen Namespaces zu erstellen. Dies ist praktisch für die Entwicklung, sollte POCs aber nicht in der Produktion verwendet werden. Erstellen Sie für die Produktion benutzerdefinierte RBAC-Richtlinien, die nur die Berechtigungen gewähren, die für die spezifischen Ressourcen erforderlich sind, die Sie verwalten ResourceGraphDefinitions werden. Anleitungen zur Konfiguration von Berechtigungen mit den geringsten Rechten finden Sie unter und. [Kro-Berechtigungen konfigurieren](kro-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert wurde, stellen Sie sicher, dass benutzerdefinierte KRO-Ressourcen in Ihrem Cluster verfügbar sind.
**Verwenden der Konsole**
1. Navigieren Sie in der Amazon EKS-Konsole zu Ihrem Cluster
1. Wählen Sie die Registerkarte **Ressourcen**
1. Wählen Sie **Erweiterungen**
1. Wählen Sie **CustomResourceDefinitions** aus.
Der `ResourceGraphDefinition` Ressourcentyp sollte aufgeführt sein.
**Verwenden Sie kubectl**
```
kubectl api-resources | grep kro.run
```
Der `ResourceGraphDefinition` Ressourcentyp sollte aufgeführt sein.
## Nächste Schritte
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
+ [Kro-Konzepte](kro-concepts.md)- Erfahren Sie mehr über SimpleSchema CEL-Ausdrücke und Kompositionsmuster
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalte deine Ressourcen für Kro-Fähigkeiten
# Erstellen Sie eine Kro-Fähigkeit mit der CLI AWS
In diesem Thema wird beschrieben, wie Sie mit der CLI eine KRO-Funktion (Kube Resource Orchestrator) erstellen. AWS
## Voraussetzungen
+ ** AWS CLI** — Version `2.12.3` oder höher. Führen Sie den Befehl aus, um Ihre Version zu überprüfen`aws --version`. Weitere Informationen finden Sie im Benutzerhandbuch für die AWS Befehlszeilenschnittstelle unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).
+ ** `kubectl` ** – Ein Befehlszeilentool für die Arbeit mit Kubernetes-Clustern. Weitere Informationen finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).
## Schritt 1: Erstellen Sie eine IAM-Capability-Rolle
Erstellen Sie eine Vertrauensrichtliniendatei:
```
cat > kro-trust-policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "capabilities.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
EOF
```
Erstellen Sie die IAM-Rolle:
```
aws iam create-role \
--role-name KROCapabilityRole \
--assume-role-policy-document file://kro-trust-policy.json
```
**Anmerkung**
Im Gegensatz zu ACK und Argo CD benötigt kro keine zusätzlichen IAM-Berechtigungen. kro arbeitet vollständig innerhalb Ihres Clusters und führt keine API-Aufrufe durch. AWS Die Rolle wird nur benötigt, um die Vertrauensstellung mit dem EKS-Capabilities Service herzustellen.
## Schritt 2: Erstellen Sie die Kro-Fähigkeit
Erstellen Sie die Kro-Capability-Ressource auf Ihrem Cluster. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet (z. B.`us-west-2`), und *my-cluster* durch Ihren Clusternamen.
```
aws eks create-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-kro \
--type KRO \
--role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/KROCapabilityRole \
--delete-propagation-policy RETAIN
```
Der Befehl wird sofort zurückgegeben, aber es dauert einige Zeit, bis die Funktion aktiv wird, da EKS die erforderliche Fähigkeitsinfrastruktur und die erforderlichen Komponenten erstellt. EKS installiert die benutzerdefinierten Kubernetes-Ressourcendefinitionen, die sich auf diese Funktion beziehen, in Ihrem Cluster, während dieser erstellt wird.
**Anmerkung**
Wenn Sie eine Fehlermeldung erhalten, dass der Cluster nicht existiert oder Sie keine Berechtigungen haben, überprüfen Sie Folgendes:
Der Clustername ist korrekt
Ihre AWS CLI ist für die richtige Region konfiguriert
Sie verfügen über die erforderlichen IAM-Berechtigungen
## Schritt 3: Stellen Sie sicher, dass die Funktion aktiv ist
Warten Sie, bis die Funktion aktiv wird. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters.
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-kro \
--query 'capability.status' \
--output text
```
Die Funktion ist bereit, wenn der Status angezeigt wird`ACTIVE`.
Sie können sich auch die vollständigen Funktionsdetails ansehen:
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-kro
```
## Schritt 4: Erteilen Sie Berechtigungen zur Verwaltung von Kubernetes-Ressourcen
Wenn Sie eine Kro-Funktion erstellen, wird automatisch ein EKS-Zugriffseintrag mit dem erstellt`AmazonEKSKROPolicy`, sodass Kro und ihre Instanzen verwalten ResourceGraphDefinitions können. Es werden jedoch standardmäßig keine Berechtigungen zum Erstellen der zugrunde liegenden Kubernetes-Ressourcen (wie Bereitstellungen, Dienste usw.) gewährt, die in ConfigMaps Ihrem definiert sind. ResourceGraphDefinitions
Dieses absichtliche Design folgt dem Prinzip der geringsten Rechte ResourceGraphDefinitions — unterschiedliche Rechte erfordern unterschiedliche Berechtigungen. Beispiel: \$1 Ein System ResourceGraphDefinition , das nur ConfigMaps Secrets erstellt, benötigt andere Berechtigungen als ein System, das Deployments und Services erstellt. \$1 Ein System ResourceGraphDefinition , das ACK-Ressourcen erstellt, benötigt Berechtigungen für diese spezifischen benutzerdefinierten Ressourcen. \$1 Manche Benutzer lesen ResourceGraphDefinitions möglicherweise nur vorhandene Ressourcen, ohne neue zu erstellen
Sie müssen die Berechtigungen, die kro benötigt, explizit auf der Grundlage der Ressourcen konfigurieren, die Sie verwalten ResourceGraphDefinitions werden.
### Quick Setup
Verwenden `AmazonEKSClusterAdminPolicy` Sie für einen schnellen Einstieg in Test- oder Entwicklungsumgebungen:
Rufen Sie den ARN der Funktionsrolle ab:
```
CAPABILITY_ROLE_ARN=$(aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-kro \
--query 'capability.roleArn' \
--output text)
```
Ordnen Sie die Cluster-Admin-Richtlinie zu:
```
aws eks associate-access-policy \
--region region-code \
--cluster-name my-cluster \
--principal-arn $CAPABILITY_ROLE_ARN \
--policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy \
--access-scope type=cluster
```
**Wichtig**
Das `AmazonEKSClusterAdminPolicy` gewährt umfassende Berechtigungen zum Erstellen und Verwalten aller Kubernetes-Ressourcen, einschließlich der Möglichkeit, beliebige Ressourcentypen in allen Namespaces zu erstellen. Dies ist praktisch für die Entwicklung, sollte POCs aber nicht in der Produktion verwendet werden. Erstellen Sie für die Produktion benutzerdefinierte RBAC-Richtlinien, die nur die Berechtigungen gewähren, die für die spezifischen Ressourcen erforderlich sind, die Sie verwalten ResourceGraphDefinitions werden. Anleitungen zur Konfiguration von Berechtigungen mit den geringsten Rechten finden Sie unter und. [Kro-Berechtigungen konfigurieren](kro-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Schritt 5: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte KRO-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep kro.run
```
Der `ResourceGraphDefinition` Ressourcentyp sollte aufgeführt sein.
## Nächste Schritte
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
+ [Kro-Konzepte](kro-concepts.md)- Erfahren Sie mehr über SimpleSchema CEL-Ausdrücke und Kompositionsmuster
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalte deine Ressourcen für Kro-Fähigkeiten
# Erstellen Sie eine Kro-Fähigkeit mit eksctl
In diesem Thema wird beschrieben, wie Sie mit eksctl eine Kro-Fähigkeit (Kube Resource Orchestrator) erstellen.
**Anmerkung**
Für die folgenden Schritte ist die Version eksctl oder höher erforderlich. `0.220.0` Führen Sie den Befehl aus, um Ihre Version zu überprüfen. `eksctl version`
## Schritt 1: Erstellen Sie eine IAM-Capability-Rolle
Erstellen Sie eine Vertrauensrichtliniendatei:
```
cat > kro-trust-policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "capabilities.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
EOF
```
Erstellen Sie die IAM-Rolle:
```
aws iam create-role \
--role-name KROCapabilityRole \
--assume-role-policy-document file://kro-trust-policy.json
```
**Anmerkung**
Im Gegensatz zu ACK und Argo CD benötigt kro keine zusätzlichen IAM-Berechtigungen, die über die Vertrauensrichtlinie hinausgehen. Kro arbeitet ausschließlich innerhalb Ihres Clusters und führt keine API-Aufrufe durch. AWS
## Schritt 2: Erstellen Sie die Kro-Fähigkeit
Erstellen Sie die Kro-Fähigkeit mit eksctl. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters.
```
eksctl create capability \
--region region-code \
--cluster my-cluster \
--name my-kro \
--type KRO \
--role-arn arn:aws:iam::[.replaceable]111122223333:role/KROCapabilityRole
```
Der Befehl kehrt sofort zurück, aber es dauert einige Zeit, bis die Funktion aktiv wird.
## Schritt 3: Stellen Sie sicher, dass die Funktion aktiv ist
Überprüfen Sie den Status der Fähigkeit. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters.
```
eksctl get capability \
--region region-code \
--cluster my-cluster \
--name my-kro
```
Die Funktion ist bereit, wenn der Status angezeigt wird`ACTIVE`.
## Schritt 4: Erteilen Sie Berechtigungen zur Verwaltung von Kubernetes-Ressourcen
Standardmäßig kann Kro nur deren Instanzen erstellen ResourceGraphDefinitions und verwalten. Damit kro die zugrunde liegenden Kubernetes-Ressourcen, die in Ihrem definiert sind, erstellen und verwalten kann ResourceGraphDefinitions, verknüpfen Sie die `AmazonEKSClusterAdminPolicy` Zugriffsrichtlinie mit dem Zugriffseintrag der Funktion.
Rufen Sie den ARN der Funktionsrolle ab:
```
CAPABILITY_ROLE_ARN=$(aws eks describe-capability \
--region region-code \
--cluster my-cluster \
--name my-kro \
--query 'capability.roleArn' \
--output text)
```
Ordnen Sie die Cluster-Admin-Richtlinie zu:
```
aws eks associate-access-policy \
--region region-code \
--cluster my-cluster \
--principal-arn $CAPABILITY_ROLE_ARN \
--policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy \
--access-scope type=cluster
```
**Wichtig**
Die `AmazonEKSClusterAdminPolicy` gewährt umfassende Berechtigungen zur Erstellung und Verwaltung aller Kubernetes-Ressourcen und soll den Einstieg vereinfachen. Für den produktiven Einsatz sollten Sie restriktivere RBAC-Richtlinien erstellen, die nur die Berechtigungen gewähren, die für die spezifischen Ressourcen erforderlich sind, die Sie verwalten werden. ResourceGraphDefinitions Anleitungen zur Konfiguration von Berechtigungen mit den geringsten Rechten finden Sie unter und. [Kro-Berechtigungen konfigurieren](kro-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Schritt 5: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte KRO-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep kro.run
```
Der `ResourceGraphDefinition` Ressourcentyp sollte aufgeführt sein.
## Nächste Schritte
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
+ [Kro-Konzepte](kro-concepts.md)- Erfahren Sie mehr über SimpleSchema CEL-Ausdrücke und Kompositionsmuster
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalte deine Ressourcen für Kro-Fähigkeiten
# Kro-Konzepte
kro ermöglicht es Plattformteams, benutzerdefinierte Kubernetes zu erstellen, die mehrere Ressourcen zu Abstraktionen auf APIs höherer Ebene zusammensetzen. In diesem Thema wird ein praktisches Beispiel vorgestellt und anschließend die Kernkonzepte erklärt, die Sie verstehen müssen, wenn Sie mit der EKS-Funktion für kro arbeiten.
## Erste Schritte mit Kro
Nachdem Sie die Kro-Fähigkeit erstellt haben (siehe[Eine Kro-Fähigkeit erstellen](create-kro-capability.md)), können Sie APIs mit der Erstellung benutzerdefinierter Anwendungen ResourceGraphDefinitions in Ihrem Cluster beginnen.
Hier ist ein vollständiges Beispiel, das eine einfache Abstraktion einer Webanwendung erstellt:
```
apiVersion: kro.run/v1alpha1
kind: ResourceGraphDefinition
metadata:
name: webapplication
spec:
schema:
apiVersion: v1alpha1
kind: WebApplication
group: kro.run
spec:
name: string | required=true
image: string | default="nginx:latest"
replicas: integer | default=3
resources:
- id: deployment
template:
apiVersion: apps/v1
kind: Deployment
metadata:
name: ${schema.spec.name}
spec:
replicas: ${schema.spec.replicas}
selector:
matchLabels:
app: ${schema.spec.name}
template:
metadata:
labels:
app: ${schema.spec.name}
spec:
containers:
- name: app
image: ${schema.spec.image}
ports:
- containerPort: 80
- id: service
template:
apiVersion: v1
kind: Service
metadata:
name: ${schema.spec.name}
spec:
selector:
app: ${schema.spec.name}
ports:
- protocol: TCP
port: 80
targetPort: 80
```
Nach der Anwendung ResourceGraphDefinition können Anwendungsteams Webanwendungen mithilfe Ihrer vereinfachten API erstellen:
```
apiVersion: kro.run/v1alpha1
kind: WebApplication
metadata:
name: my-app
spec:
name: my-app
replicas: 5
```
kro erstellt das Deployment und den Service automatisch mit der entsprechenden Konfiguration. Da `image` nicht angegeben ist, wird der Standardwert `nginx:latest` aus dem Schema verwendet.
## Schlüsselkonzepte
**Wichtig**
kro validiert zur Zeit ResourceGraphDefinitions der Erstellung, nicht zur Laufzeit. Wenn Sie eine RGD erstellen, validiert Kro die CEL-Syntax, überprüft Ausdrücke anhand der tatsächlichen Kubernetes-Schemas, verifiziert das Vorhandensein von Feldern und erkennt zirkuläre Abhängigkeiten. Das bedeutet, dass Fehler sofort bei der Erstellung der RGD erkannt werden, bevor Instanzen bereitgestellt werden.
### ResourceGraphDefinition
A ResourceGraphDefinition (RGD) definiert eine benutzerdefinierte Kubernetes-API durch Angabe von:
+ **Schema** — Die API-Struktur unter Verwendung des SimpleSchema Formats (Feldnamen, Typen, Standardwerte, Validierung)
+ **Ressourcen** — Vorlagen für das zugrunde liegende Kubernetes oder AWS zu erstellende Ressourcen
+ **Abhängigkeiten** — Wie Ressourcen zueinander in Beziehung stehen (wird automatisch anhand von Feldreferenzen erkannt)
Wenn Sie eine RGD anwenden, registriert Kro eine neue benutzerdefinierte Ressourcendefinition (CRD) in Ihrem Cluster. Anwendungsteams können dann Instanzen Ihrer benutzerdefinierten API erstellen, und kro kümmert sich um die Erstellung und Verwaltung aller zugrunde liegenden Ressourcen.
Weitere Informationen finden Sie in der Kro-Dokumentation unter [ResourceGraphDefinition Überblick](https://kro.run/docs/concepts/rgd/overview/).
### SimpleSchema formatieren
SimpleSchema bietet eine vereinfachte Möglichkeit, API-Schemas zu definieren, ohne dass OpenAPI-Kenntnisse erforderlich sind:
```
schema:
apiVersion: v1alpha1
kind: Database
spec:
name: string | required=true description="Database name"
size: string | default="small" enum=small,medium,large
replicas: integer | default=1 minimum=1 maximum=5
```
SimpleSchema unterstützt`string`, `integer``boolean`, und `number` Typen mit Einschränkungen wie`required`,`default`,`minimum`/`maximum``enum`, und. `pattern`
Weitere Informationen finden Sie [SimpleSchema](https://kro.run/docs/concepts/rgd/schema/)in der KRO-Dokumentation.
### CEL-Ausdrücke
kro verwendet Common Expression Language (CEL), um Werte dynamisch zu referenzieren und bedingte Logik hinzuzufügen. CEL-Ausdrücke sind in `${` und eingeschlossen `}` und können auf zwei Arten verwendet werden:
**Eigenständige Ausdrücke** — Der gesamte Feldwert ist ein einziger Ausdruck:
```
spec:
replicas: ${schema.spec.replicaCount} # Expression returns integer
labels: ${schema.spec.labelMap} # Expression returns object
```
Das Ausdrucksergebnis ersetzt den gesamten Feldwert und muss dem erwarteten Feldtyp entsprechen.
**Zeichenkettenvorlagen** — Ein oder mehrere Ausdrücke, die in eine Zeichenfolge eingebettet sind:
```
metadata:
name: "${schema.spec.prefix}-${schema.spec.name}" # Multiple expressions
annotation: "Created by ${schema.spec.owner}" # Single expression in string
```
Alle Ausdrücke in Zeichenkettenvorlagen müssen Zeichenketten zurückgeben. Wird verwendet`string()`, um andere Typen zu konvertieren:`"replicas-${string(schema.spec.count)}"`.
**Feldverweise** — Greifen Sie auf Instanzspezifikationswerte zu, indem Sie`schema.spec`:
```
template:
metadata:
name: ${schema.spec.name}-deployment
namespace: ${schema.metadata.namespace} # Can also reference metadata
spec:
replicas: ${schema.spec.replicas}
```
**Optionaler Feldzugriff** — Wird `?` für Felder verwendet, die möglicherweise nicht existieren:
```
# For ConfigMaps or Secrets with unknown structure
value: ${configmap.data.?DATABASE_URL}
# For optional status fields
ready: ${deployment.status.?readyReplicas > 0}
```
Wenn das Feld nicht existiert, wird der Ausdruck zurückgegeben `null` und schlägt nicht fehl.
**Bedingte Ressourcen** — Beziehen Sie Ressourcen nur ein, wenn die Bedingungen erfüllt sind:
```
resources:
- id: ingress
includeWhen:
- ${schema.spec.enableIngress == true}
template:
# ... ingress configuration
```
Das `includeWhen` Feld akzeptiert eine Liste von booleschen Ausdrücken. Alle Bedingungen müssen erfüllt sein, damit die Ressource erstellt werden kann. Derzeit `includeWhen` können nur `schema.spec` Felder referenziert werden.
**Transformationen** — Transformieren Sie Werte mit ternären Operatoren und Funktionen:
```
template:
spec:
resources:
requests:
memory: ${schema.spec.size == "small" ? "512Mi" : "2Gi"}
# String concatenation
image: ${schema.spec.registry + "/" + schema.spec.imageName}
# Type conversion
port: ${string(schema.spec.portNumber)}
```
**Ressourcenübergreifende Referenzen** — Referenzwerte aus anderen Ressourcen:
```
resources:
- id: bucket
template:
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
spec:
name: ${schema.spec.name}-data
- id: configmap
template:
apiVersion: v1
kind: ConfigMap
data:
BUCKET_NAME: ${bucket.spec.name}
BUCKET_ARN: ${bucket.status.ackResourceMetadata.arn}
```
Wenn Sie in einem CEL-Ausdruck auf eine andere Ressource verweisen, wird automatisch eine Abhängigkeit erstellt. kro stellt sicher, dass die referenzierte Ressource zuerst erstellt wird.
Weitere Informationen finden Sie in der [KRO-Dokumentation unter CEL-Ausdrücke](https://kro.run/docs/concepts/rgd/cel-expressions/).
### Abhängigkeiten von Ressourcen
kro leitet Abhängigkeiten automatisch aus CEL-Ausdrücken ab — Sie geben die Reihenfolge nicht an, sondern beschreiben Beziehungen. Wenn eine Ressource mithilfe eines CEL-Ausdrucks auf eine andere Ressource verweist, erstellt Kro eine Abhängigkeit und bestimmt die richtige Erstellungsreihenfolge.
```
resources:
- id: bucket
template:
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
spec:
name: ${schema.spec.name}-data
- id: notification
template:
apiVersion: s3.services.k8s.aws/v1alpha1
kind: BucketNotification
spec:
bucket: ${bucket.spec.name} # Creates dependency: notification depends on bucket
```
Der Ausdruck `${bucket.spec.name}` erzeugt eine Abhängigkeit. kro erstellt einen gerichteten azyklischen Graphen (DAG) aller Ressourcen und ihrer Abhängigkeiten und berechnet dann eine topologische Reihenfolge für die Erstellung.
**Erstellungsreihenfolge**: Ressourcen werden in topologischer Reihenfolge erstellt (Abhängigkeiten zuerst).
**Parallele Erstellung**: Ressourcen ohne Abhängigkeiten werden gleichzeitig erstellt.
**Löschreihenfolge**: Ressourcen werden in umgekehrter topologischer Reihenfolge gelöscht (abhängige Objekte zuerst).
**Zirkuläre Abhängigkeiten**: Nicht zulässig — kro lehnt ResourceGraphDefinitions bei der Validierung zirkuläre Abhängigkeiten ab.
Sie können die berechnete Erstellungsreihenfolge einsehen:
```
kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.status.topologicalOrder}'
```
Weitere Informationen finden Sie unter [Graph-Inferenz](https://kro.run/docs/concepts/rgd/dependencies-ordering/) in der KRO-Dokumentation.
## Komponieren mit ACK
kro arbeitet nahtlos mit der EKS-Funktion für ACK zusammen, um AWS Ressourcen mit Kubernetes-Ressourcen zusammenzustellen:
```
resources:
# Create {aws} S3 bucket with ACK
- id: bucket
template:
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
spec:
name: ${schema.spec.name}-files
# Inject bucket details into Kubernetes ConfigMap
- id: config
template:
apiVersion: v1
kind: ConfigMap
data:
BUCKET_NAME: ${bucket.spec.name}
BUCKET_ARN: ${bucket.status.ackResourceMetadata.arn}
# Use ConfigMap in application deployment
- id: deployment
template:
apiVersion: apps/v1
kind: Deployment
spec:
template:
spec:
containers:
- name: app
envFrom:
- configMapRef:
name: ${config.metadata.name}
```
Mit diesem Muster können Sie AWS Ressourcen erstellen, ihre Details (ARNs, URLs, Endpunkte) extrahieren und sie in Ihre Anwendungskonfiguration einfügen — alles wird als eine Einheit verwaltet.
Weitere Kompositionsmuster und Beispiele für Fortgeschrittene finden Sie unter. [Überlegungen zu Kro für EKS](kro-considerations.md)
## Nächste Schritte
+ [Überlegungen zu Kro für EKS](kro-considerations.md)- Erfahren Sie mehr über EKS-spezifische Muster, RBAC und die Integration mit ACK und Argo CD
+ [kro-Dokumentation — Umfassende Kro-Dokumentation](https://kro.run/docs/overview) mit erweiterten CEL-Ausdrücken, Validierungsmustern und Problemlösungen
# Kro-Berechtigungen konfigurieren
Im Gegensatz zu ACK und Argo CD benötigt kro keine IAM-Berechtigungen. kro arbeitet vollständig in Ihrem Kubernetes-Cluster und führt keine API-Aufrufe durch. AWS Steuern Sie den Zugriff auf Kro-Ressourcen mithilfe des Standard-Kubernetes-RBAC.
## Wie funktionieren Berechtigungen mit Kro
kro verwendet zwei Arten von Kubernetes-Ressourcen mit unterschiedlichen Bereichen:
**ResourceGraphDefinitions**: Ressourcen im Clusterbereich, die benutzerdefinierte definieren. APIs In der Regel von Plattformteams verwaltet, die organisatorische Standards entwerfen und einhalten.
**Instanzen: Benutzerdefinierte** Ressourcen mit Namespace-Gültigkeitsbereich, die aus erstellt wurden. ResourceGraphDefinitions Kann von Anwendungsteams mit entsprechenden RBAC-Berechtigungen erstellt werden.
Standardmäßig verfügt die KRO-Funktion über die Zugriffsrichtlinie über Berechtigungen zum Verwalten ResourceGraphDefinitions und Verwalten ihrer Instanzen. `AmazonEKSKROPolicy` Für Kro sind jedoch zusätzliche Berechtigungen erforderlich, um die zugrunde liegenden Kubernetes-Ressourcen zu erstellen und zu verwalten, die in Ihrem System definiert sind ResourceGraphDefinitions (z. B. Bereitstellungen, Dienste oder ACK-Ressourcen). Sie müssen diese Berechtigungen über Zugriffsrichtlinien oder Kubernetes RBAC gewähren. Einzelheiten zur Erteilung dieser Berechtigungen finden Sie unter [Kro](capabilities-security.md#kro-resource-permissions) Arbitrary Resource Permissions.
## Berechtigungen für Plattformteams
Plattformteams benötigen Berechtigungen zum Erstellen und Verwalten ResourceGraphDefinitions.
**Beispiel ClusterRole für Plattformteams**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: kro-platform-admin
rules:
- apiGroups: ["kro.run"]
resources: ["resourcegraphdefinitions"]
verbs: ["*"]
```
**Binden Sie sich an Mitglieder des Plattform-Teams**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: platform-team-kro-admin
subjects:
- kind: Group
name: platform-team
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: kro-platform-admin
apiGroup: rbac.authorization.k8s.io
```
## Berechtigungen des Anwendungsteams
Anwendungsteams benötigen Berechtigungen, um Instanzen benutzerdefinierter Ressourcen in ihren Namespaces zu erstellen.
**Beispielrolle für Anwendungsteams**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: kro-app-developer
namespace: my-app
rules:
- apiGroups: ["kro.run"]
resources: ["webapps", "databases"]
verbs: ["create", "get", "list", "update", "delete", "patch"]
```
An **Mitglieder des Anwendungsteams binden**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: app-team-kro-developer
namespace: my-app
subjects:
- kind: Group
name: app-team
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: Role
name: kro-app-developer
apiGroup: rbac.authorization.k8s.io
```
**Anmerkung**
Die API-Gruppe in der Rolle (`kro.run`in diesem Beispiel) muss der in Ihrem ResourceGraphDefinition Schema `apiVersion` definierten entsprechen.
## Schreibgeschützter Zugriff
Gewähren Sie schreibgeschützten Zugriff auf Ansicht ResourceGraphDefinitions und Instanzen ohne Änderungsberechtigungen.
**Schreibgeschützt: ClusterRole**
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: kro-viewer
rules:
- apiGroups: ["kro.run"]
resources: ["resourcegraphdefinitions"]
verbs: ["get", "list", "watch"]
```
**Schreibgeschützte Rolle für Instanzen**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: kro-instance-viewer
namespace: my-app
rules:
- apiGroups: ["kro.run"]
resources: ["webapps", "databases"]
verbs: ["get", "list", "watch"]
```
## Zugriff auf mehrere Namespaces
Gewähren Sie Anwendungsteams mithilfe von with Zugriff auf mehrere Namespaces. ClusterRoles RoleBindings
**ClusterRole für** den Zugriff auf mehrere Namespaces:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: kro-multi-namespace-developer
rules:
- apiGroups: ["kro.run"]
resources: ["webapps"]
verbs: ["create", "get", "list", "update", "delete"]
```
An **bestimmte Namespaces binden**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: app-team-dev-access
namespace: development
subjects:
- kind: Group
name: app-team
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: kro-multi-namespace-developer
apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: app-team-staging-access
namespace: staging
subjects:
- kind: Group
name: app-team
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: kro-multi-namespace-developer
apiGroup: rbac.authorization.k8s.io
```
## Best Practices
**Prinzip der geringsten Rechte**: Erteilen Sie nur die Mindestberechtigungen, die für die jeweiligen Aufgaben der einzelnen Teams erforderlich sind.
**Verwenden Sie Gruppen statt einzelner Benutzer**: Binden Sie Rollen eher an Gruppen als an einzelne Benutzer, um die Verwaltung zu vereinfachen.
**Getrennte Plattform- und Anwendungsaspekte**: Plattformteams verwalten ResourceGraphDefinitions, Anwendungsteams verwalten Instanzen.
**Namespace-Isolierung**: Verwenden Sie Namespaces, um verschiedene Teams oder Umgebungen zu isolieren, wobei RBAC den Zugriff auf jeden Namespace steuert.
**Schreibgeschützter Zugriff für Auditzwecke: Gewähren Sie Sicherheits- und Compliance-Teams zu Prüfungszwecken nur** Lesezugriff.
## Nächste Schritte
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie SimpleSchema CEL-Ausdrücke und Kompositionsmuster
+ [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)- Informieren Sie sich über bewährte Sicherheitsverfahren im Hinblick auf Funktionen
# Überlegungen zu Kro für EKS
In diesem Thema werden wichtige Überlegungen zur Verwendung der EKS-Funktion für KRO behandelt, einschließlich der Frage, wann die Ressourcenzusammensetzung, RBAC-Muster und die Integration mit anderen EKS-Funktionen verwendet werden sollten.
## Wann sollte Kro verwendet werden
kro wurde für die Erstellung wiederverwendbarer und benutzerdefinierter Infrastrukturmuster entwickelt APIs , die das komplexe Ressourcenmanagement vereinfachen.
**Verwenden Sie kro, wenn Sie**:
+ Erstellen Sie Self-Service-Plattformen mit vereinfachten Funktionen APIs für Anwendungsteams
+ Standardisieren Sie die Infrastrukturmuster für alle Teams (Datenbank \$1 Backup \$1 Überwachung)
+ Verwalten Sie Ressourcenabhängigkeiten und geben Sie Werte zwischen Ressourcen weiter
+ Erstellen Sie benutzerdefinierte Abstraktionen, die die Komplexität der Implementierung verbergen
+ Stellen Sie mehrere ACK-Ressourcen zu übergeordneten Bausteinen zusammen
+ Ermöglichen Sie GitOps Workflows für komplexe Infrastruktur-Stacks
**Verwenden Sie Kro nicht**, wenn:
+ Verwaltung einfacher, eigenständiger Ressourcen (verwenden Sie ACK- oder Kubernetes-Ressourcen direkt)
+ Sie benötigen eine dynamische Laufzeitlogik (kro ist deklarativ, nicht zwingend erforderlich)
+ Ressourcen haben keine Abhängigkeiten oder eine gemeinsame Konfiguration
kro zeichnet sich durch die Schaffung von „gepflasterten Pfaden“ aus — eigensinnige, wiederverwendbare Muster, die es Teams leicht machen, komplexe Infrastrukturen korrekt bereitzustellen.
## RBAC-Muster
kro ermöglicht die Trennung von Problemen zwischen Plattformteams, die Instanzen erstellen, ResourceGraphDefinitions und Anwendungsteams, die Instanzen erstellen.
### Verantwortlichkeiten des Plattformteams
Plattformteams erstellen und verwalten ResourceGraphDefinitions (RGDs), die benutzerdefiniert definieren APIs.
**Erforderliche Berechtigungen**:
+ Erstellen, aktualisieren, löschen ResourceGraphDefinitions
+ Verwalten Sie die zugrunde liegenden Ressourcentypen (Bereitstellungen, Dienste, ACK-Ressourcen)
+ Zugriff auf alle Namespaces, in denen sie verwendet werden RGDs
**Beispiel ClusterRole für ein Plattformteam**:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: platform-kro-admin
rules:
- apiGroups: ["kro.run"]
resources: ["resourcegraphdefinitions"]
verbs: ["*"]
- apiGroups: ["*"]
resources: ["*"]
verbs: ["get", "list", "watch"]
```
Eine ausführliche RBAC-Konfiguration finden Sie unter. [Kro-Berechtigungen konfigurieren](kro-permissions.md)
### Verantwortlichkeiten des Anwendungsteams
Anwendungsteams erstellen Instanzen von benutzerdefinierten Ressourcen, die von definiert sind, RGDs ohne die zugrundeliegende Komplexität verstehen zu müssen.
**Erforderliche Berechtigungen**:
+ Instanzen von benutzerdefinierten Ressourcen erstellen, aktualisieren und löschen
+ Lesezugriff auf ihren Namespace
+ Kein Zugriff auf zugrunde liegende Ressourcen oder RGDs
**Vorteile**:
+ Teams verwenden einfache, hochrangige APIs
+ Plattformteams kontrollieren die Implementierungsdetails
+ Geringeres Risiko einer Fehlkonfiguration
+ Schnelleres Onboarding für neue Teammitglieder
## Integration mit anderen EKS-Funktionen
### Zusammenstellung von ACK-Ressourcen
Kro ist besonders leistungsfähig, wenn es mit ACK kombiniert wird, um Infrastrukturmuster zu erstellen.
**Allgemeine Muster**:
+ **Anwendung mit Speicher**: S3-Bucket \$1 SQS-Warteschlange \$1 Benachrichtigungskonfiguration
+ **Datenbank-Stack**: RDS-Instanz \$1 Parametergruppe \$1 Sicherheitsgruppe \$1 Secrets Manager Secret
+ **Netzwerk**: VPC \$1 Subnetze \$1 Routentabellen \$1 Sicherheitsgruppen \$1 NAT-Gateways
+ **Datenverarbeitung mit Speicher**: EC2 Instanz \$1 EBS-Volumes \$1 IAM-Instanzprofil
kro kümmert sich um die Reihenfolge der Abhängigkeiten, übergibt Werte zwischen Ressourcen (wie Zeichenketten ARNs und Verbindungszeichenfolgen) und verwaltet den gesamten Lebenszyklus als eine einzige Einheit.
Beispiele für das Zusammenstellen von ACK-Ressourcen finden Sie unter. [ACK-Konzepte](ack-concepts.md)
### GitOps mit Argo CD
Verwenden Sie die EKS-Funktion für Argo CD, um sowohl RGDs Instanzen als auch Instanzen aus Git-Repositorys bereitzustellen.
**Organisation des Repositorys**:
+ **Plattform-Repo**: Enthält, die vom Plattformteam ResourceGraphDefinitions verwaltet werden
+ **Anwendungs-Repos**: Enthalten Instanzen von benutzerdefinierten Ressourcen, die von App-Teams verwaltet werden
+ **Gemeinsames Repo**: Enthält RGDs sowohl als auch Instanzen für kleinere Organisationen
**Überlegungen**:
+ RGDs Vor den Instanzen bereitstellen (Argo CD Sync Waves kann helfen)
+ Verwenden Sie separate Argo-CD-Projekte für Plattform- und Anwendungsteams
+ Das Plattformteam kontrolliert den Zugriff auf das RGD-Repository
+ Anwendungsteams haben nur Lesezugriff auf RGD-Definitionen
Weitere Informationen zu Argo CD finden Sie unter. [Arbeiten mit Argo CD](working-with-argocd.md)
## Organisieren ResourceGraphDefinitions
Organisieren Sie RGDs nach Zweck, Komplexität und Eigentümerschaft.
**Nach Zweck**:
+ **Infrastruktur**: Datenbank-Stacks, Netzwerke, Speicher
+ **Anwendung**: Web-Apps APIs, Batch-Jobs
+ **Plattform**: Gemeinsame Dienste, Überwachung, Protokollierung
**Nach Komplexität**:
+ **Einfach**: 2-3 Ressourcen mit minimalen Abhängigkeiten
+ **Moderat**: 5-10 Ressourcen mit einigen Abhängigkeiten
+ **Komplex**: Mehr als 10 Ressourcen mit komplexen Abhängigkeiten
**Benennungskonventionen**:
+ Verwenden Sie beschreibende Namen:`webapp-with-database`, `s3-notification-queue`
+ Fügen Sie bei wichtigen Änderungen die Version in den Namen ein: `webapp-v2`
+ Verwenden Sie konsistente Präfixe für verwandte RGDs:`platform- `, `app-`
**Namespace-Strategie**:
+ RGDs sind clusterbezogen (nicht namespaces)
+ Instanzen haben einen Namespace
+ Verwenden Sie Namespace-Selektoren, RGDs um zu steuern, wo Instanzen erstellt werden können
## Versionierung und Updates
Planen Sie die RGD-Entwicklung und die Instanzmigration ein.
**RGD-Aktualisierungen**:
+ **Wichtige Änderungen:** RGD wurde bereits aktualisiert (optionale Felder und neue Ressourcen mit includeWhen hinzufügen)
+ **Bahnbrechende Änderungen**: Erstelle eine neue RGD mit einem anderen Namen (webapp-v2)
+ **Veraltet: Veraltete Version** mit Anmerkungen markieren, Zeitplan für die Migration RGDs mitteilen
**Migration von Instanzen:**
+ Erstellen Sie neue Instanzen mit aktualisiertem RGD
+ Stellen Sie sicher, dass neue Instanzen korrekt funktionieren
+ Löschen Sie alte Instanzen
+ kro verarbeitet die Aktualisierungen der zugrunde liegenden Ressourcen automatisch
**Bewährte Verfahren**:
+ Testen Sie RGD-Änderungen zunächst in Umgebungen außerhalb der Produktion
+ Verwenden Sie für größere Änderungen die semantische Versionierung in RGD-Namen
+ Dokumentieren Sie wichtige Änderungen und Migrationspfade
+ Stellen Sie Migrationsbeispiele für Anwendungsteams bereit
## Validierung und Testen
Validieren RGDs Sie vor der Bereitstellung in der Produktion.
**Strategien zur Validierung**:
+ **Schemavalidierung**: kro validiert die RGD-Struktur automatisch
+ **Testinstanzen: Erstellen Sie Testinstanzen in Entwicklungs-Namespaces**
+ **Integrationstests**: Stellen Sie sicher, dass zusammengesetzte Ressourcen zusammenarbeiten
+ **Durchsetzung von Richtlinien**: Setzen Sie Zugangscontroller ein, um Unternehmensstandards durchzusetzen
**Häufig zu testende Probleme**:
+ Abhängigkeiten und Reihenfolge von Ressourcen
+ Werteübergabe zwischen Ressourcen (CEL-Ausdrücke)
+ Bedingte Einbeziehung von Ressourcen (includeWhen)
+ Weitergabe des Status anhand der zugrunde liegenden Ressourcen
+ RBAC-Berechtigungen für die Instanzerstellung
## Upstream-Dokumentation
Ausführliche Informationen zur Verwendung von kro finden Sie unter
+ [Erste Schritte mit Kro](https://kro.run/docs/guides/getting-started) — Erstellen ResourceGraphDefinitions
+ [CEL-Ausdrücke](https://kro.run/docs/concepts/cel) — CEL-Ausdrücke schreiben
+ [kro Guides](https://kro.run/docs/guides/) - Kompositionsmuster für Fortgeschrittene
+ [Problembehandlung — Problembehebung](https://kro.run/docs/troubleshooting) und Debugging
## Nächste Schritte
+ [Kro-Berechtigungen konfigurieren](kro-permissions.md)- Konfigurieren Sie RBAC für Plattform- und Anwendungsteams
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und den Ressourcenlebenszyklus
+ [Probleme mit KRO-Funktionen beheben](kro-troubleshooting.md)- Beheben Sie Kro-Probleme
+ [ACK-Konzepte](ack-concepts.md)- Erfahren Sie mehr über ACK-Ressourcen für die Komposition
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Bereitstellung RGDs und Instanzen mit GitOps
# Probleme mit KRO-Funktionen beheben
Dieses Thema enthält Anleitungen zur Fehlerbehebung für die EKS-Funktion für KRO, einschließlich Funktionsprüfungen, RBAC-Berechtigungen, CEL-Ausdrucksfehler und Probleme bei der Ressourcenzusammensetzung.
**Anmerkung**
EKS-Funktionen werden vollständig verwaltet und außerhalb Ihres Clusters ausgeführt. Sie haben keinen Zugriff auf Controller-Logs oder den `kro-system` Namespace. Die Fehlerbehebung konzentriert sich auf den Funktionsstatus, die RBAC-Konfiguration und den Ressourcenstatus.
## Die Funktion ist AKTIV, funktioniert aber ResourceGraphDefinitions nicht
Wenn Ihre Kro-Fähigkeit `ACTIVE` den Status anzeigt, aber ResourceGraphDefinitions keine zugrunde liegenden Ressourcen erstellt werden, überprüfen Sie den Zustand der Fähigkeit, die RBAC-Berechtigungen und den Ressourcenstatus.
**Überprüfen Sie den Zustand** der Fähigkeit:
Sie können Funktionszustands- und Statusprobleme in der EKS-Konsole oder über die AWS CLI anzeigen.
**Konsole**:
1. Öffnen Sie die Amazon EKS-Konsole unter https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Wählen Sie Ihren Clusternamen aus.
1. Wählen Sie den Registerkarte **Beobachtbarkeit**.
1. Wählen Sie **Cluster überwachen** aus.
1. Wählen Sie die Registerkarte **Funktionen**, um den Zustand und den Status aller Funktionen anzuzeigen.
** AWS CLI**:
```
# View capability status and health
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-kro
# Look for issues in the health section
```
**Häufige Ursachen:**
+ **RBAC-Berechtigungen fehlen**: Kro hat keine Berechtigungen, um zugrunde liegende Kubernetes-Ressourcen zu erstellen
+ **Ungültige CEL-Ausdrücke**: Syntaxfehler in ResourceGraphDefinition
+ **Ressourcenabhängigkeiten**: Abhängige Ressourcen sind nicht bereit
+ **Schemavalidierung**: Die Instanz entspricht nicht den RGD-Schemaanforderungen
**Überprüfen Sie die RBAC-Berechtigungen**:
```
# Check if capability has cluster admin policy
kubectl get accessentry -A | grep kro
```
Wenn die Funktion nicht über die erforderlichen Berechtigungen verfügt, verknüpfen Sie sie `AmazonEKSClusterAdminPolicy` mit dem Zugriffseintrag der KRO-Funktion, oder erstellen Sie restriktivere RBAC-Richtlinien für den Produktionsgebrauch. Details dazu finden Sie unter [Kro-Berechtigungen konfigurieren](kro-permissions.md).
**Status überprüfen: ResourceGraphDefinition **
```
# List all RGDs
kubectl get resourcegraphdefinition
# Describe specific RGD
kubectl describe resourcegraphdefinition my-rgd
# Check for validation errors
kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.status.conditions}'
```
ResourceGraphDefinitions haben drei wichtige Statusbedingungen:
+ `ResourceGraphAccepted`- Ob das RGD die Validierung bestanden hat (CEL-Syntax, Typprüfung, Existenz des Felds)
+ `KindReady`- Ob die CRD für Ihre benutzerdefinierte API generiert und registriert wurde
+ `ControllerReady`- Ob Kro aktiv nach Instanzen Ihrer benutzerdefinierten API Ausschau hält
Falls ja `ResourceGraphAccepted``False`, überprüfen Sie die Zustandsmeldung auf Validierungsfehler wie unbekannte Felder, nicht übereinstimmende Typen oder zirkuläre Abhängigkeiten.
## Instanzen wurden erstellt, aber die zugrunde liegenden Ressourcen werden nicht angezeigt
Wenn benutzerdefinierte Ressourceninstanzen existieren, die zugrunde liegenden Kubernetes-Ressourcen (Bereitstellungen, Dienste, ConfigMaps) jedoch nicht erstellt werden, überprüfen Sie, ob kro über die erforderlichen Berechtigungen verfügt, und überprüfen Sie, ob Kompositionsfehler vorliegen.
**Überprüfen Sie den Instanzstatus:**
```
# Describe the instance (replace with your custom resource kind and name)
kubectl describe custom-kind
my-instance
# View instance events
kubectl get events --field-selector involvedObject.name=my-instance
# Check instance status conditions
kubectl get custom-kind
my-instance -o jsonpath='{.status.conditions}'
# Check instance state
kubectl get custom-kind
my-instance -o jsonpath='{.status.state}'
```
Instanzen haben ein `state` Feld, das den Status auf hoher Ebene anzeigt:
+ `ACTIVE`— Die Instanz wird erfolgreich ausgeführt
+ `IN_PROGRESS`- Die Instanz wird verarbeitet oder abgeglichen
+ `FAILED`- Die Instanz konnte nicht abgeglichen werden
+ `DELETING`- Die Instanz wird gelöscht
+ `ERROR`- Bei der Verarbeitung ist ein Fehler aufgetreten
Instanzen haben außerdem vier Statusbedingungen:
+ `InstanceManaged`- Finalizer und Labels sind richtig gesetzt
+ `GraphResolved`- Laufzeitdiagramm erstellt und Ressourcen aufgelöst
+ `ResourcesReady`- Alle Ressourcen wurden erstellt und sind bereit
+ `Ready`- Allgemeiner Zustand der Instanz (wird nur erreicht`True`, wenn alle Unterbedingungen erfüllt sind`True`)
Konzentrieren Sie sich auf den `Ready` Zustand, um den Zustand der Instanz zu bestimmen. Falls `Ready` ja`False`, überprüfen Sie anhand der Unterbedingungen, welche Phase fehlgeschlagen ist.
**Überprüfen Sie die RBAC-Berechtigungen**:
Für die Kro-Funktion sind Berechtigungen erforderlich, um die zugrunde liegenden Kubernetes-Ressourcen zu erstellen, die in Ihrem definiert sind. ResourceGraphDefinitions
```
# Check if the capability has the AmazonEKSClusterAdminPolicy
kubectl get accessentry -A | grep kro
```
Wenn Berechtigungen fehlen, verknüpfen Sie sie `AmazonEKSClusterAdminPolicy` mit dem Zugriffseintrag der Kro-Fähigkeit oder erstellen Sie restriktivere RBAC-Richtlinien für den Produktionsgebrauch. Details dazu finden Sie unter [Kro-Berechtigungen konfigurieren](kro-permissions.md).
## Fehler bei CEL-Ausdrücken
Fehler bei CEL-Ausdrücken werden bei der ResourceGraphDefinition Erstellung erkannt, nicht bei der Erstellung von Instances. Kro validiert die gesamte CEL-Syntax, überprüft Ausdrücke anhand von Kubernetes-Schemas und überprüft das Vorhandensein von Feldern, wenn Sie die RGD erstellen.
**Häufige Fehler** bei der CEL-Validierung:
+ **Undefinierter Feldverweis**: Verweisen auf ein Feld, das im Schema oder in der Ressource nicht vorhanden ist
+ **Typkonflikt**: Der Ausdruck gibt einen falschen Typ zurück (z. B. eine Zeichenfolge, bei der eine Ganzzahl erwartet wurde)
+ **Ungültige Syntax**: Fehlende Klammern, Anführungszeichen oder Operatoren im CEL-Ausdruck
+ **Unbekannter Ressourcentyp**: Verweist auf eine CRD, die im Cluster nicht vorhanden ist
**Überprüfen Sie den RGD-Validierungsstatus**:
```
# Check if RGD was accepted
kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.status.conditions[?(@.type=="ResourceGraphAccepted")]}'
# View detailed validation errors
kubectl describe resourcegraphdefinition my-rgd
```
Falls ja `ResourceGraphAccepted``False`, enthält die Zustandsmeldung den Validierungsfehler.
**Beispiel für gültige CEL-Ausdrücke**:
```
# Reference schema field
${schema.spec.appName}
# Conditional expression
${schema.spec.replicas > 1}
# String template (expressions must return strings)
name: "${schema.spec.appName}-service"
# Standalone expression (can be any type)
replicas: ${schema.spec.replicaCount}
# Resource reference
${deployment.status.availableReplicas}
# Optional field access (returns null if field doesn't exist)
${configmap.data.?DATABASE_URL}
```
## Ressourcenabhängigkeiten werden nicht aufgelöst
kro leitet automatisch Abhängigkeiten aus CEL-Ausdrücken ab und erstellt Ressourcen in der richtigen Reihenfolge. Wenn Ressourcen nicht wie erwartet erstellt werden, überprüfen Sie die Reihenfolge der Abhängigkeiten und die Verfügbarkeit der Ressourcen.
**Berechnete Erstellungsreihenfolge anzeigen**:
```
# See the order kro will create resources
kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.status.topologicalOrder}'
```
Dies zeigt die berechnete Reihenfolge auf der Grundlage von CEL-Ausdrucksverweisen zwischen Ressourcen.
**Überprüfen Sie die Verfügbarkeit der Ressourcen:**
```
# View instance status to see which resources are ready
kubectl get custom-kind
my-instance -o jsonpath='{.status}'
# Check specific resource status
kubectl get deployment my-deployment -o jsonpath='{.status.conditions}'
```
**Überprüfen Sie die ReadyWhen-Bedingungen (falls verwendet)**:
Das Feld `readyWhen` ist optional. Wenn nicht angegeben, gelten Ressourcen unmittelbar nach der Erstellung als bereit. Wenn Sie `readyWhen` Bedingungen definiert haben, stellen Sie sicher, dass diese korrekt prüfen, ob die Ressourcen bereit sind:
```
resources:
- id: deployment
readyWhen:
- ${deployment.status.availableReplicas == deployment.spec.replicas}
```
**Überprüfen Sie die Ressourcenereignisse**:
```
# View events for the underlying resources
kubectl get events -n namespace --sort-by='.lastTimestamp'
```
## Fehler bei der Schemavalidierung
Wenn Instanzen aufgrund von Fehlern bei der Schemavalidierung nicht erstellt werden können, überprüfen Sie, ob die Instanz die RGD-Schemaanforderungen erfüllt.
**Überprüfen Sie die Validierungsfehler**:
```
# Attempt to create instance and view error
kubectl apply -f instance.yaml
# View existing instance validation status
kubectl describe custom-kind
my-instance | grep -A 5 "Validation"
```
**Häufige Probleme bei der Validierung**:
+ **Erforderliche Felder fehlen**: Die Instanz stellt nicht alle erforderlichen Schemafelder bereit
+ **Typkonflikt**: Es wird eine Zeichenfolge bereitgestellt, bei der eine Ganzzahl erwartet wird
+ **Ungültiger Aufzählungswert: Es wird ein Wert** verwendet, der nicht in der Liste der zulässigen Werte steht
+ **Musterkonflikt: Die Zeichenfolge stimmt** nicht mit dem Regex-Muster überein
**RGD-Schema überprüfen**:
```
# View the schema definition
kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.spec.schema}'
```
Stellen Sie sicher, dass Ihre Instanz alle erforderlichen Felder mit den richtigen Typen bereitstellt.
## Nächste Schritte
+ [Überlegungen zu Kro für EKS](kro-considerations.md)- Überlegungen und bewährte Methoden zu KRO
+ [Kro-Berechtigungen konfigurieren](kro-permissions.md)- Konfigurieren Sie RBAC für Plattform- und Anwendungsteams
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und den Ressourcenlebenszyklus
+ [Problembehebung bei EKS-Funktionen](capabilities-troubleshooting.md)- Allgemeine Hinweise zur Problembehebung
# Vergleich der EKS-Funktionen für Kro mit selbstverwaltetem Kro
Die EKS-Funktion für Kro bietet dieselbe Funktionalität wie selbstverwaltetes Kro, bietet jedoch erhebliche betriebliche Vorteile. Einen allgemeinen Vergleich zwischen EKS-Funktionen und selbstverwalteten Lösungen finden Sie unter. [Überlegungen zu den EKS-Fähigkeiten](capabilities-considerations.md)
Die EKS-Funktion für Kro verwendet dieselben Upstream-Kro-Controller und ist vollständig kompatibel mit Upstream-Kro. ResourceGraphDefinitions, CEL-Ausdrücke und Ressourcenzusammensetzung funktionieren identisch. Eine vollständige Kro-Dokumentation und Beispiele finden Sie in der [Kro-Dokumentation](https://kro.run/docs/overview).
## Migrationspfad
Sie können ohne Ausfallzeiten von selbstverwaltetem KRO zur verwalteten Funktion migrieren.
**Wichtig**
Stellen Sie vor der Migration sicher, dass auf Ihrem selbstverwalteten Kro-Controller dieselbe Version wie die EKS-Funktion für Kro ausgeführt wird. Überprüfen Sie die Funktionsversion in der EKS-Konsole oder verwenden Sie Ihre selbstverwaltete Installation `aws eks describe-capability` und führen Sie anschließend ein entsprechendes Upgrade durch. Dadurch werden Kompatibilitätsprobleme während der Migration vermieden.
1. Aktualisieren Sie Ihren selbstverwalteten Kro-Controller so, dass er ihn `kube-system` für Leasingverträge zur Wahl von Führungskräften verwenden kann:
```
helm upgrade --install kro \
oci://ghcr.io/awslabs/kro/kro-chart \
--namespace kro \
--set leaderElection.namespace=kube-system
```
Dadurch wird der Leasingvertrag des Controllers auf diesen übertragen`kube-system`, sodass sich die verwaltete Kapazität darauf abstimmen kann.
1. Erstellen Sie die Kro-Fähigkeit auf Ihrem Cluster (siehe[Eine Kro-Fähigkeit erstellen](create-kro-capability.md))
1. Die verwaltete Funktion erkennt bestehende Instanzen ResourceGraphDefinitions und übernimmt den Abgleich
1. Skalieren Sie selbstverwaltete KRO-Bereitstellungen schrittweise oder entfernen Sie sie:
```
helm uninstall kro --namespace kro
```
Dieser Ansatz ermöglicht eine sichere Koexistenz beider Controller während der Migration. Die verwaltete Funktion übernimmt automatisch Instanzen ResourceGraphDefinitions und Instanzen, die zuvor von einem selbstverwalteten KRO verwaltet wurden, sodass ein kontinuierlicher Abgleich ohne Konflikte gewährleistet ist.
## Nächste Schritte
+ [Eine Kro-Fähigkeit erstellen](create-kro-capability.md)- Erstellen Sie eine Kro-Fähigkeitsressource
+ [Kro-Konzepte](kro-concepts.md)- Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen