

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

# Bereiten Sie lokale Amazon EKS-Cluster vor auf AWS Outposts, die mit EC2-Instance-Speicher für Netzwerkunterbrechungen konfiguriert sind
<a name="eks-outposts-instance-store-network-disconnects"></a>

Wenn der AWS Outposts-Servicelink, der Ihr lokales Netzwerk mit der AWS Cloud verbindet, die Konnektivität verloren hat, können Sie Ihren lokalen Amazon EKS-Cluster weiterhin auf einem Outpost verwenden. In diesem Thema erfahren Sie, wie Sie Ihren lokalen Cluster auf Netzwerkunterbrechungen vorbereiten können, und damit verbundene Überlegungen.
+ Lokale Cluster sorgen für Stabilität und unterbrechungsfreien Betrieb bei vorübergehenden, ungeplanten Netzwerkunterbrechungen. AWS Outposts bleibt ein vollständig vernetztes Angebot, das als Erweiterung der AWS Cloud in Ihrem Rechenzentrum fungiert. Im Falle von Netzwerkunterbrechungen zwischen Ihrem Outpost und der AWS Cloud empfehlen wir, zu versuchen, Ihre Verbindung wiederherzustellen. Anweisungen finden Sie in der [Checkliste zur Fehlerbehebung im AWS Outposts-Rack-Netzwerk](https://docs.aws.amazon.com/outposts/latest/userguide/network-troubleshoot.html) im * AWS Outposts-Benutzerhandbuch.*
+ Outposts geben eine `ConnectedStatus`-Metrik aus, mit der Sie den Konnektivitätsstatus Ihres Outposts überwachen können. Weitere Informationen finden Sie unter [Outposts-Metriken](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-cloudwatch-metrics.html#outposts-metrics) im * AWS Outposts-Benutzerhandbuch*.

## Authentifizierung bei Netzwerkunterbrechungen
<a name="eks-outposts-instance-store-network-disconnects-authentication"></a>

Lokale Cluster unterstützen mehrere Authentifizierungsmechanismen. Ihre Verfügbarkeit bei Netzwerkunterbrechungen ist unterschiedlich:


| Authentifizierungsmechanismus | Während der Trennung verfügbar? | 
| --- | --- | 
|  AWS IAM (Zugriffseinträge, `aws-auth` ConfigMap) | Nein. IAM erfordert Konnektivität mit der AWS Region. | 
| OIDC (vom Kunden bereitgestellter Anbieter) | Hängt vom Standort des Anbieters ab. Wenn der OIDC-Anbieter vom lokalen Netzwerk des Outpost aus erreichbar ist, funktioniert die Authentifizierung weiterhin. | 
| x.509-Client-Zertifikate | Ja. Zertifikate werden lokal vom Kubernetes-API-Server validiert. | 
| IRSA (IAM-Rollen für Dienstkonten) | Nein. Siehst du[IRSA und Pod Identity bei Verbindungsabbrüchen](#eks-outposts-instance-store-network-disconnects-irsa). | 
| EKS Pod Identity | Nein. Siehst du[IRSA und Pod Identity bei Verbindungsabbrüchen](#eks-outposts-instance-store-network-disconnects-irsa). | 

### x.509-Client-Zertifikate
<a name="eks-outposts-instance-store-network-disconnects-x509"></a>

Um den `kubectl` Zugriff auch bei Netzwerkunterbrechungen aufrechtzuerhalten, erstellen Sie ein X.509-Zertifikat für den Client, bevor die Verbindung unterbrochen wird.

Um ein Admin-Zertifikat zu erstellen:

1. Generieren Sie einen privaten Schlüssel und eine Zertifikatsignieranforderung (CSR):

   ```
   openssl req -new -newkey rsa:4096 -nodes \
       -keyout admin.key -out admin.csr -subj "/CN=admin"
   ```

1. Erstellen Sie eine `CertificateSigningRequest` Kubernetes-Ressource und genehmigen Sie sie:

   ```
   cat admin.csr | base64 | tr -d '\n' > admin.csr.b64
   ```

   ```
   apiVersion: certificates.k8s.io/v1
   kind: CertificateSigningRequest
   metadata:
     name: admin-csr
   spec:
     request: <base64-encoded-csr>
     signerName: kubernetes.io/kube-apiserver-client
     usages:
       - client auth
   ```

   ```
   kubectl apply -f admin-csr.yaml
   kubectl certificate approve admin-csr
   ```

1. Rufen Sie das signierte Zertifikat ab:

   ```
   kubectl get csr admin-csr -o jsonpath='{.status.certificate}' | base64 --decode > admin.crt
   ```

1. Erstellen Sie ein`ClusterRoleBinding`, um Administratorzugriff zu gewähren:

   ```
   kubectl create clusterrolebinding admin --clusterrole=cluster-admin \
       --user=admin --group=system:masters
   ```

1. Erstellen Sie eine`kubeconfig`, die das Zertifikat verwendet:

   ```
   kubectl config --kubeconfig admin.kubeconfig set-cluster my-cluster \
       --certificate-authority=ca.crt --server $APISERVER_ENDPOINT --embed-certs
   kubectl config --kubeconfig admin.kubeconfig set-credentials admin \
       --client-certificate=admin.crt --client-key=admin.key --embed-certs
   kubectl config --kubeconfig admin.kubeconfig set-context admin@my-cluster \
       --cluster my-cluster --user admin
   kubectl config --kubeconfig admin.kubeconfig use-context admin@my-cluster
   ```

### DNS-Auflösung des Clusterendpunkts bei Verbindungsabbrüchen
<a name="eks-outposts-instance-store-network-disconnects-cluster-dns"></a>

Der Kubernetes-API-Serverendpunkt für einen lokalen Cluster wird in Amazon Route 53 gehostet und in die privaten IP-Adressen der kontoübergreifenden Elastic Network Interfaces (ENIs) aufgelöst, die Amazon EKS in Ihren Subnetzen erstellt. Diese ENIs haben statische private IP-Adressen, die sich während des normalen Clusterbetriebs nicht ändern.

Während einer Netzwerkunterbrechung kann der Outpost Route 53 nicht erreichen, sodass der Hostname des Cluster-Endpunkts nur aufgelöst wird, wenn Sie einen lokalen Auflösungspfad vorbereitet haben. Drei Kategorien von Clients müssen den API-Server erreichen:
+  **Clusteradministratoren** werden ausgeführt`kubectl`.
+  **Worker-Knoten** (`kubelet`) senden Knoten-Heartbeats und rufen Spezifikationen ab.
+  **`kube-proxy`**auf jedem Knoten, der Clusterdienst-IPs einrichtet.

#### Option 1: lokale DNS-Lösung (empfohlen)
<a name="_option_1_local_dns_solution_recommended"></a>

 AWS empfiehlt die Bereitstellung einer lokalen DNS-Lösung, die die Cluster-Endpunkteinträge zwischenspeichert und sie bereitstellt, während der Outpost getrennt ist. Sie können Ihren eigenen DNS-Server in Ihrer lokalen Umgebung ausführen, der die Cluster-Endpunkteinträge zwischenspeichert.

Wenn Sie eine lokale DNS-Lösung verwenden, empfehlen wir, Ihre AMIs `kubeconfig` und Ihre Worker-Node-AMIs auf den Hostnamen des Cluster-Endpunkts (nicht auf ENI-IP-Adressen) zu richten, damit die Auflösung mit der lokalen DNS-Lösung konsistent ist.

#### Option 2: statischer Zugriff IP-based
<a name="_option_2_static_ip_based_access"></a>

Wenn Sie keine lokale DNS-Lösung ausführen möchten, können Sie den statischen IP-based Zugriff verwenden.
+  **Administratoren:** Konfigurieren Sie Ihr System so`kubeconfig`, dass es direkt auf eine kontoübergreifende private ENI-IP-Adresse verweist. Finden Sie die ENIs, indem Sie mit der Beschreibung `Amazon EKS {{cluster-name}} ` in Ihrem AWS Konto nach Netzwerkschnittstellen suchen. Die IP-Adressen der einzelnen ENI sind bei normalem Betrieb für die gesamte Lebensdauer des Clusters stabil.
+  **Worker-Knoten (Amazon EKS-optimierte AMIs):** Wenn Sie Worker-Knoten von einem Amazon EKS-optimierten AMI aus starten, fügt das Bootstrap-Skript den Cluster-Endpunkt `/etc/hosts` mit den ENI-IP-Adressen hinzu. Es ist keine zusätzliche Konfiguration erforderlich.
+  **Worker-Knoten (benutzerdefinierte AMIs):** Fügen Sie den Hostnamen des Cluster-Endpunkts und die ENI-IP-Adressen zu `/etc/hosts` Ihrem benutzerdefinierten Bootstrap hinzu. Andernfalls `kubelet` `kube-proxy` kann der API-Server während einer Unterbrechung nicht erreicht werden.

**Wichtig**  
Wenn eine kontoübergreifende ENI gelöscht wird oder sich ihre IP-Adresse ändert — wenn Sie sie beispielsweise löschen oder so ändern, dass Amazon EKS sie nicht erneut anhängt — müssen jeder Knoten und jeder Administrator, der statischen IP-based Zugriff verwendet, manuell aktualisiert werden. Bei einer lokalen DNS-Lösung ist kein manuelles Eingreifen erforderlich.

### Pod-DNS-Auflösung bei Verbindungsabbrüchen
<a name="eks-outposts-instance-store-network-disconnects-pod-dns"></a>

Um DNS-Fehler während eines unterbrochenen Betriebs zu verhindern, konfigurieren Sie Ihre Worker-Node-Startvorlage so, dass die Einstellung überschrieben `kubelet’s `resolvConf` wird. Erstellen Sie in Ihren Benutzerdaten eine benutzerdefinierte `resolv.conf` Datei (z. B.`/etc/kubernetes/resolv.conf`), die nur `nameserver 10.0.0.2` (ohne die VPC-Suchdomäne) enthält, und legen Sie `spec.kubelet.config.resolvConf: /etc/kubernetes/resolv.conf` dann Ihre fest. `NodeConfig` Dadurch wird die ` {{region-code}}.compute.internal` Suchdomäne aus der Pod-DNS-Konfiguration entfernt und verhindert, dass Anfragen an den nicht erreichbaren VPC-DNS-Resolver weitergeleitet werden, wenn die Verbindung unterbrochen wird.

Das folgende Beispiel zeigt die Benutzerdaten des Worker-Nodes:

```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="BOUNDARY"

--BOUNDARY
Content-Type: text/x-shellscript; charset="us-ascii"

#!/bin/bash
mkdir -p /etc/kubernetes
echo "nameserver [.replaceable]``10.0.0.2``" > /etc/kubernetes/resolv.conf

--BOUNDARY
Content-Type: application/node.eks.aws

---
apiVersion: node.eks.aws/v1alpha1
kind: NodeConfig
spec:
  cluster:
    name: my-cluster
    ...
  kubelet:
    config:
      resolvConf: /etc/kubernetes/resolv.conf

--BOUNDARY--
```

### IRSA und Pod Identity bei Verbindungsabbrüchen
<a name="eks-outposts-instance-store-network-disconnects-irsa"></a>

**Wichtig**  
IRSA und EKS Pod Identity hängen von AWS STS ab, das in der Region ausgeführt wird. AWS Während einer Netzwerkunterbrechung können Workloads, die IRSA oder Pod Identity verwenden, keine neuen Anmeldeinformationen abrufen. Bestehende Anmeldeinformationen laufen nach einer gewissen Zeit ab.

Es wird nicht empfohlen, funktionale oder betriebliche Abhängigkeiten von Region-based AWS Diensten für Workloads einzugehen, die auch bei Netzwerkunterbrechungen verfügbar bleiben müssen.

## `Verhalten von etcd` bei Verbindungsabbrüchen
<a name="eks-outposts-instance-store-network-disconnects-etcd"></a>

Bei Netzwerkunterbrechungen können `etcd` Snapshots nicht gesichert werden. Wenn während einer Verbindungsunterbrechung mehr als eine `etcd` Instanz nicht verfügbar ist, geht das Quorum `etcd` verloren und Kubernetes-API-Operationen sind erst verfügbar, wenn Ihr Outpost die Verbindung wieder herstellt und das Quorum wiederhergestellt wurde. `etcd` Workloads, die bereits ausgeführt werden, funktionieren weiterhin.

## Protokollierung der Kontrollebene bei Verbindungsabbrüchen
<a name="eks-outposts-instance-store-network-disconnects-cp-logs"></a>

Bei Netzwerkunterbrechungen werden die Protokolle der Kontrollebene lokal auf den Kontrollebeneninstanzen zwischengespeichert. Wenn die Konnektivität wiederhergestellt ist, werden die Protokolle an Amazon CloudWatch Logs in der übergeordneten AWS Region gesendet. Sie müssen keinen Logging-Agenten auf der Steuerungsebene installieren oder verwalten.

## Lokale Beobachtbarkeit
<a name="eks-outposts-instance-store-network-disconnects-local-observability"></a>

Sie können Ihren Cluster bei Verbindungsabbrüchen lokal überwachen, indem Sie [Prometheus](https://prometheus.io/), [Grafana](https://grafana.com/) oder andere Drittanbieterlösungen verwenden, um den Endpunkt der Kubernetes-API-Servermetriken zu durchsuchen.

## Lokales Bild-Repository
<a name="eks-outposts-instance-store-network-disconnects-image-repo"></a>

Um Bereitstellungen mit zusätzlichen Replikaten zu skalieren oder um Pod-Fehler bei Verbindungsabbrüchen wiederherzustellen, benötigen Sie ein lokales Container-Image-Repository (z. B. eine Docker-Registry), oder die Images müssen vor dem Trennen der Verbindung auf dem Knoten zwischengespeichert werden. Amazon ECR ist bei Netzwerkunterbrechungen nicht verfügbar.

## Passen Sie das Failover-Verhalten des Kubernetes-Pods an
<a name="eks-outposts-instance-store-network-disconnects-pod-failover"></a>

Während einer Netzwerkunterbrechung kann die Kubernetes-Steuerebene nicht mit der Region kommunizieren. AWS Wenn ein Knoten nicht mehr erreichbar ist, besteht das Standardverhalten von Kubernetes darin, Pods nach einem Timeout zu entfernen. Sie können dieses Verhalten mithilfe von Toleranzen und `tolerationSeconds` anhand Ihrer Pod-Spezifikationen anpassen, um zu steuern, wie schnell Pods während einer Partition neu geplant werden. Ausführliche Anleitungen und Beispiele finden Sie unter https://docs.aws.amazon.com/eks/latest/best-practices/hybrid-nodes-network-disconnection-best-practices.html \# *tune\_kubernetes\_pod\_failover\_behavior [Tune Kubernetes-Pod-Failover-Verhalten] im \_Amazon EKS* Best Practices Guide.

## Simulieren Sie eine Netzwerkunterbrechung
<a name="eks-outposts-instance-store-network-disconnects-simulate"></a>

Bevor Sie mit Ihrem lokalen Cluster in die Produktion gehen, simulieren Sie eine Unterbrechung, um sicherzustellen, dass Sie auf Ihren Cluster zugreifen können, wenn er getrennt ist.

1. Wenden Sie Firewallregeln auf die Netzwerkgeräte an, die Ihren Outpost mit der AWS Region verbinden. Dadurch wird der Service-Link des Outposts getrennt.

1. Testen Sie die Verbindung zu Ihrem lokalen Cluster mithilfe des von Ihnen erstellten x.509-Zertifikats:

   ```
   kubectl --kubeconfig admin.kubeconfig get nodes
   ```

**Anmerkung**  
Wenn auf Ihrem Outpost bereits Dienste in Produktion sind, simulieren Sie keine Unterbrechung. Das Trennen der Service-Verbindung wirkt sich auf alle Dienste aus, die auf dem Outpost ausgeführt werden.