**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.

# Bereitstellung einer Beispiel-Workload für Load Balancer in EKS Auto Mode
<a name="auto-elb-example"></a>

Dieser Leitfaden führt Sie durch die Bereitstellung einer containerisierten Version des Spiels 2048 in Amazon EKS, einschließlich Load Balancing und Internetzugänglichkeit.

## Voraussetzungen
<a name="_prerequisites"></a>
+ Ein EKS-Auto-Mode-Cluster
+  `kubectl` für die Interaktion mit Ihrem Cluster konfiguriert
+ Geeignete IAM-Berechtigungen für die Erstellung von ALB-Ressourcen

## Schritt 1: Namespace erstellen
<a name="_step_1_create_the_namespace"></a>

Erstellen Sie zunächst einen dedizierten Namespace für die 2048-Spiel-Anwendung.

Erstellen Sie eine Datei namens `01-namespace.yaml`:

```
apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
```

Wenden Sie die Namespace-Konfiguration an:

```
kubectl apply -f 01-namespace.yaml
```

## Schritt 2: Anwendung bereitstellen
<a name="_step_2_deploy_the_application"></a>

Die Anwendung führt mehrere Replikate des 2048-Spiel-Containers aus.

Erstellen Sie eine Datei namens `02-deployment.yaml`:

```
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  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
          resources:
            requests:
              cpu: "0.5"
```

**Anmerkung**  
Sollten beim Laden des Images `public.ecr.aws/l6m2t8p7/docker-2048:latest` Fehler auftreten, überprüfen Sie, ob Ihre Knoten-IAM-Rolle über ausreichende Berechtigungen verfügt, um Images aus ECR abzurufen. Weitere Informationen finden Sie unter [Knoten-IAM-Rolle](auto-learn-iam.md#auto-learn-node-iam-role). Beachten Sie, dass es sich bei dem `docker-2048`-Image im Beispiel um ein `x86_64`-Image handelt, das in anderen Architekturen nicht ausgeführt werden kann.

 **Zentrale Komponenten:** 
+ Stellt 5 Replikate der Anwendung bereit
+ Verwendet ein öffentliches ECR-Image
+ Erfordert 0,5 CPU-Kerne pro Pod
+ Stellt Port 80 für HTTP-Datenverkehr bereit

Bereitstellung durchführen:

```
kubectl apply -f 02-deployment.yaml
```

## Schritt 3: Service erstellen
<a name="_step_3_create_the_service"></a>

Der Service macht die Bereitstellung für das Cluster-Netzwerk sichtbar.

Erstellen Sie eine Datei namens `03-service.yaml`:

```
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    app.kubernetes.io/name: app-2048
```

 **Zentrale Komponenten:** 
+ Erstellt einen NodePort-Service
+ Ordnet Port 80 dem Port 80 des Containers zu
+ Verwendet den Label-Selektor, um Pods zu finden

Wenden Sie den Service an:

```
kubectl apply -f 03-service.yaml
```

## Schritt 4: Load Balancing konfigurieren
<a name="_step_4_configure_load_balancing"></a>

Sie richten einen Ingress ein, um die Anwendung im Internet verfügbar zu machen.

Erstellen Sie zunächst die `IngressClass`. Erstellen Sie eine Datei namens `04-ingressclass.yaml`:

```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  labels:
    app.kubernetes.io/name: LoadBalancerController
  name: alb
spec:
  controller: eks.amazonaws.com/alb
```

**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).

Erstellen Sie anschließend die Ingress-Ressource. Erstellen Sie eine Datei namens `05-ingress.yaml`:

```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80
```

 **Zentrale Komponenten:** 
+ Erstellt ein internetbasiertes ALB
+ Verwendet den IP-Zieltyp für die direkte Pod-Weiterleitung
+ Leitet den gesamten Datenverkehr (/) an den Spiele-Service weiter

Wenden Sie die Ingress-Konfigurationen an:

```
kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml
```

## Schritt 5: Bereitstellung überprüfen
<a name="_step_5_verify_the_deployment"></a>

1. Vergewissern Sie sich, dass alle Pods ausgeführt werden:

   ```
   kubectl get pods -n game-2048
   ```

1. Überprüfen Sie, ob der Service erstellt wurde:

   ```
   kubectl get svc -n game-2048
   ```

1. Rufen Sie den ALB-Endpunkt ab:

   ```
   kubectl get ingress -n game-2048
   ```

Das Feld ADDRESS in der Ingress-Ausgabe zeigt Ihren ALB-Endpunkt an. Warten Sie 2–3 Minuten, bis der ALB alle Ziele bereitgestellt und registriert hat.

## Schritt 6: Auf das Spiel zugreifen
<a name="_step_6_access_the_game"></a>

Öffnen Sie Ihren Web-Browser und navigieren Sie zur ALB-Endpunkt-URL aus dem vorherigen Schritt. Sie sollten nun die 2048-Spieloberfläche sehen.

## Schritt 7: Bereinigen
<a name="_step_7_cleanup"></a>

So entfernen Sie alle in diesem Tutorial erstellten Ressourcen:

```
kubectl delete namespace game-2048
```

Dadurch werden alle Ressourcen im Namespace gelöscht, einschließlich der Bereitstellungs-, Service- und Ingress-Ressourcen.

## Was hinter den Kulissen passiert
<a name="_whats_happening_behind_the_scenes"></a>

1. Die Bereitstellung erstellt fünf Pods, in denen das Spiel 2048 ausgeführt wird

1. Der Service bietet einen stabilen Netzwerkzugang zu diesen Pods

1. EKS Auto Mode:
   + Erstellt einen Application Load Balancer in AWS 
   + Konfiguriert Zielgruppen für die Pods
   + Richtet Routing-Regeln ein, um den Datenverkehr zum Service zu leiten

## Fehlersuche
<a name="auto-elb-troubleshooting"></a>

Falls das Spiel nicht geladen wird:
+ Stellen Sie sicher, dass alle Pods ausgeführt werden: `kubectl get pods -n game-2048` 
+ Überprüfen Sie den Ingress-Status: `kubectl describe ingress -n game-2048` 
+ Überprüfen Sie die ALB-Zustandsprüfungen: Zustand der Zielgruppe in der AWS-Konsole überprüfen