**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.
# Erstellen Sie einen IngressClass , um einen Application Load Balancer zu konfigurieren
EKS Auto Mode automatisiert Routineaufgaben für den Lastausgleich, einschließlich der Bereitstellung von Cluster-Anwendungen im Internet
AWS schlägt vor, Application Load Balancers (ALB) für den HTTP- und HTTPS-Verkehr zu verwenden. Application Load Balancers können Anfragen basierend auf dem Inhalt der Anfrage weiterleiten. Weitere Informationen über Application Load Balancer finden Sie unter [Was ist elastischer Lastenausgleich?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html).
EKS Auto Mode erstellt und konfiguriert Application Load Balancer (ALBs). Beispielsweise erstellt EKS Auto Mode einen Load Balancer, wenn Sie ein `Ingress`-Kubernetes-Objekt erstellen, und konfiguriert ihn so, dass der Datenverkehr an Ihre Cluster-Workload weitergeleitet wird.
**Übersicht**
1. Erstellen Sie eine Workload, die Sie im Internet verfügbar machen möchten.
1. Erstellen Sie eine `IngressClassParams` Ressource und geben Sie AWS bestimmte Konfigurationswerte an, z. B. das zu verwendende Zertifikat SSL/TLS und VPC-Subnetze.
1. Erstellen Sie eine `IngressClass`-Ressource und legen Sie fest, dass EKS Auto Mode als Controller für die Ressource dienen soll.
1. Erstellen Sie eine `Ingress`-Ressource, die einen HTTP-Pfad und einen Port mit einer Cluster-Workload verknüpft.
EKS Auto Mode erstellt einen Application Load Balancer, der auf die in der `Ingress`-Ressource angegebene Workload verweist und die in der `IngressClassParams`-Ressource angegebene Load-Balancer-Konfiguration verwendet.
## Voraussetzungen
+ EKS Auto Mode in einem Amazon-EKS-Cluster aktiviert
+ Kubectl für die Verbindung mit Ihrem Cluster konfiguriert
+ Sie können `kubectl apply -f ` verwenden um die unten aufgeführten YAML-Beispiel-Konfigurationsdateien in Ihren Cluster anwenden.
**Anmerkung**
EKS Auto Mode erfordert Subnetz-Tags zur Identifizierung öffentlicher und privater Subnetze.
Wenn Sie Ihren Cluster mit `eksctl` erstellt haben, verfügen Sie bereits über diese Tags.
Weitere Informationen erhalten Sie unter [Kennzeichnung von Subnetzen für EKS Auto Mode](tag-subnets-auto.md).
## Schritt 1: Workload erstellen
Erstellen Sie zunächst eine Workload, die Sie im Internet verfügbar machen möchten. Dies kann jede Kubernetes-Ressource sein, die HTTP-Datenverkehr bereitstellt, z. B. eine Bereitstellung oder ein Service.
In diesem Beispiel wird ein einfacher HTTP-Service mit dem Namen `service-2048` verwendet, der auf Port `80` empfangsbereit ist. Erstellen Sie diesen Service und dessen Bereitstellung, indem Sie das folgende Manifest `2048-deployment-service.yaml` anwenden:
```
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-2048
spec:
selector:
matchLabels:
app.kubernetes.io/name: app-2048
replicas: 2
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
name: app-2048
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: service-2048
spec:
ports:
- port: 80
targetPort: 80
protocol: TCP
type: NodePort
selector:
app.kubernetes.io/name: app-2048
```
Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f 2048-deployment-service.yaml
```
Die oben aufgeführten Ressourcen werden im Standard-Namespace erstellt. Sie können dies durch Ausführung des folgenden Befehls überprüfen:
```
kubectl get all -n default
```
## Schritt 2: Erstellen IngressClassParams
Erstellen Sie ein `IngressClassParams` Objekt, um AWS spezifische Konfigurationsoptionen für den Application Load Balancer anzugeben. In diesem Beispiel erstellen wir eine `IngressClassParams`-Ressource mit dem Namen `alb` (die Sie im nächsten Schritt verwenden werden), die das Load-Balancer-Schema als `internet-facing` in einer Datei mit dem Namen `alb-ingressclassparams.yaml` festlegt.
```
apiVersion: eks.amazonaws.com/v1
kind: IngressClassParams
metadata:
name: alb
spec:
scheme: internet-facing
```
Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f alb-ingressclassparams.yaml
```
## Schritt 3: Erstellen IngressClass
Erstellen Sie eine`IngressClass`, die auf die AWS spezifischen Konfigurationswerte verweist, die in der `IngressClassParams` Ressource in einer Datei mit dem Namen festgelegt sind`alb-ingressclass.yaml`. Notieren Sie den Namen des `IngressClass`. In diesem Beispiel haben sowohl `IngressClass` als auch `IngressClassParams` den Namen `alb`.
Verwenden Sie die `is-default-class`-Annotation, um zu steuern, ob `Ingress`-Ressourcen diese Klasse standardmäßig verwenden sollen.
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
# Use this annotation to set an IngressClass as Default
# If an Ingress doesn't specify a class, it will use the Default
ingressclass.kubernetes.io/is-default-class: "true"
spec:
# Configures the IngressClass to use EKS Auto Mode
controller: eks.amazonaws.com/alb
parameters:
apiGroup: eks.amazonaws.com
kind: IngressClassParams
# Use the name of the IngressClassParams set in the previous step
name: alb
```
Weitere Informationen zu den Konfigurationsoptionen finden Sie unter [IngressClassParams Referenz](#ingress-reference).
Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f alb-ingressclass.yaml
```
## Schritt 4: Ingress erstellen
Erstellen Sie eine `Ingress`-Ressource in einer Datei mit dem Namen `alb-ingress.yaml`. Der Zweck dieser Ressource besteht darin, Pfade und Ports dem Application Load Balancer mit Workloads in Ihrem Cluster zuzuordnen. Für dieses Beispiel erstellen wir eine `Ingress`-Ressource mit dem Namen `2048-ingress`, die den Datenverkehr an einen Service mit dem Namen `service-2048` auf Port 80 weiterleitet.
Weitere Informationen zum Konfigurieren dieser Ressource finden Sie unter [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) in der Kubernetes-Dokumentation.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: 2048-ingress
spec:
# this matches the name of IngressClass.
# this can be omitted if you have a default ingressClass in cluster: the one with ingressclass.kubernetes.io/is-default-class: "true" annotation
ingressClassName: alb
rules:
- http:
paths:
- path: /*
pathType: ImplementationSpecific
backend:
service:
name: service-2048
port:
number: 80
```
Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f alb-ingress.yaml
```
## Schritt 5: Status überprüfen
Verwenden Sie `kubectl`, um den Status von `Ingress` zu ermitteln. Es kann einige Minuten dauern, bis der Load Balancer verfügbar ist.
Verwenden Sie den Namen der `Ingress`-Ressource, die Sie im vorherigen Schritt festgelegt haben. Beispiel:
```
kubectl get ingress 2048-ingress
```
Sobald die Ressource bereit ist, rufen Sie den Domain-Namen des Load Balancers ab.
```
kubectl get ingress 2048-ingress -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'
```
Um den Dienst in einem Webbrowser anzuzeigen, überprüfen Sie den Port und den Pfad, die in der `Ingress` Ressource angegeben sind.
## Schritt 6: Bereinigen
Zur Bereinigung des Load Balancer verwenden Sie den folgenden Befehl:
```
kubectl delete ingress 2048-ingress
kubectl delete ingressclass alb
kubectl delete ingressclassparams alb
```
Der automatische Modus von EKS löscht automatisch den zugehörigen Load Balancer in Ihrem AWS Konto.
## IngressClassParams Referenz
Die folgende Tabelle dient als Kurzübersicht über häufig verwendete Konfigurationsoptionen.
| Feld | Description | Beispielwert |
| --- | --- | --- |
| `scheme` | Legt fest, ob der ALB intern oder mit dem Internet verbunden ist | `internet-facing` |
| `namespaceSelector` | Schränkt ein, welche Namespaces dies verwenden können IngressClass | `environment: prod` |
| `group.name` | Gruppiert mehrere Ingresses, um einen einzigen ALB gemeinsam zu nutzen | `retail-apps` |
| `ipAddressType` | Legt den IP-Adresstyp für den ALB fest | `dualstack` |
| `subnets.ids` | Liste der Subnetz-IDs für die ALB-Bereitstellung | `subnet-xxxx, subnet-yyyy` |
| `subnets.tags` | Tag-Filter zur Auswahl von Subnetzen für ALB | `Environment: prod` |
| `certificateARNs` | ARNs der zu verwendenden SSL-Zertifikate | ` arn:aws: acm:region:account:certificate/id` |
| `tags` | Benutzerdefinierte Tags für Ressourcen AWS | `Environment: prod, Team: platform` |
| `loadBalancerAttributes` | Load-Balancer-spezifische Attribute | `idle_timeout.timeout_seconds: 60` |
## Überlegungen
+ Sie können Anmerkungen nicht für eine verwenden, IngressClass um Load Balancer mit dem automatischen EKS-Modus zu konfigurieren. IngressClass Die Konfiguration sollte wie folgt durchgeführt werden. IngressClassParams Sie können jedoch Anmerkungen zu einzelnen Ingress-Ressourcen verwenden, um das Verhalten des Load Balancers zu konfigurieren (z. B. `alb.ingress.kubernetes.io/security-group-prefix-lists` oder). `alb.ingress.kubernetes.io/conditions.*`
+ Mit dem automatischen Modus von EKS können Sie keine [ListenerAttribute](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_ListenerAttribute.html)Einstellungen vornehmen.
+ Sie müssen die Cluster-IAM-Rolle aktualisieren, um die Tag-Weitergabe von Kubernetes an AWS Load Balancer-Ressourcen zu ermöglichen. Weitere Informationen finden Sie unter [Benutzerdefinierte AWS Tags für EKS Auto-Ressourcen](auto-cluster-iam-role.md#tag-prop).
+ Informationen zum Zuordnen von Ressourcen zum automatischen Modus von EKS oder zum selbstverwalteten Load AWS Balancer Controller finden Sie unter. [Migrationsreferenz](migrate-auto.md#migration-reference)
+ Informationen zum Beheben von Problemen mit Load Balancern finden Sie unter [Fehlerbehebung mit EKS Auto Mode](auto-troubleshoot.md).
+ Weitere Überlegungen zur Verwendung der Load-Balancing-Funktion von EKS Auto Mode finden Sie unter [Lastausgleich](auto-networking.md#auto-lb-consider).
Die folgenden Tabellen bieten einen detaillierten Vergleich der Änderungen IngressClassParams, der Ingress-Anmerkungen und der TargetGroupBinding Konfigurationen für den EKS-Automatikmodus. Diese Tabellen zeigen die wichtigsten Unterschiede zwischen der Lastenausgleichsfunktion von EKS Auto Mode und dem Open-Source Load Balancer Controller auf, darunter Änderungen der API-Version, veraltete Features und aktualisierte Parameternamen.
### IngressClassParams
| Vorherige | Neu | Description |
| --- | --- | --- |
| `elbv2.k8s.aws/v1beta1` | `eks.amazonaws.com/v1` | Änderung der API-Version |
| `spec.certificateArn` | `spec.certificateARNs` | Support für mehrere Zertifikats-ARNs |
| `spec.subnets.tags` | `spec.subnets.matchTags` | Geändertes Schema für die Subnetz-Zuordnung |
| `spec.listeners.listenerAttributes` | Nicht unterstützt | Wird von EKS Auto Mode noch nicht unterstützt |
### Ingress-Annotationen
| Vorherige | Neu | Description |
| --- | --- | --- |
| `kubernetes.io/ingress.class` | Nicht unterstützt | `spec.ingressClassName` in Eingangsobjekten verwenden |
| `alb.ingress.kubernetes.io/group.name` | Nicht unterstützt | Geben Sie Gruppen nur in an IngressClass |
| `alb.ingress.kubernetes.io/waf-acl-id` | Nicht unterstützt | Stattdessen WAF v2 verwenden |
| `alb.ingress.kubernetes.io/web-acl-id` | Nicht unterstützt | Stattdessen WAF v2 verwenden |
| `alb.ingress.kubernetes.io/shield-advanced-protection` | Nicht unterstützt | Shield-Integration deaktiviert |
| `alb.ingress.kubernetes.io/auth-type: oidc` | Nicht unterstützt | OIDC-Authentifizierungstyp wird derzeit nicht unterstützt |
### TargetGroupBinding
| Vorherige | Neu | Description |
| --- | --- | --- |
| `elbv2.k8s.aws/v1beta1` | `eks.amazonaws.com/v1` | Änderung der API-Version |
| `spec.targetType` optional | `spec.targetType` erforderlich | Explizite Angabe des Zieltyps |
| `spec.networking.ingress.from` | Nicht unterstützt | NLB ohne Sicherheitsgruppen wird nicht mehr unterstützt |
Um die benutzerdefinierte TargetGroupBinding Funktion zu verwenden, müssen Sie die Zielgruppe mit dem eks:eks-cluster-name-Tag mit dem Clusternamen kennzeichnen, um dem Controller die erforderlichen IAM-Berechtigungen zu gewähren. Beachten Sie, dass der Controller die Zielgruppe löscht, wenn die Ressource oder der Cluster gelöscht wird. TargetGroupBinding