Wie kann ich die Konfiguration des HTTP-Proxys für Amazon EKS-Container-Knoten automatisieren?

Lesedauer: 10 Minute

Ich möchte die HTTP-Proxy-Konfiguration für Amazon Elastic Kubernetes Service (Amazon EKS)-Knoten mit Container-Laufzeit automatisieren.

Kurzbeschreibung

Du kannst die HTTP-Proxy-Konfiguration für Amazon EKS-Knoten mit einer benutzerdefinierten Startvorlage automatisieren, die Proxy-Einstellungen in den Benutzerdaten enthält. Der Konfigurationsansatz variiert je nach AMI-Familie: Amazon Linux 2, Amazon Linux 2023 oder Bottlerocket.

Hinweis: Für Amazon EKS-Cluster ab Version 1.24 ist containerd die Standard-Container-Laufzeit.

Lösung

Um deine verwaltete Knotengruppe mit HTTP-Proxy-Einstellungen zu konfigurieren, erstelle eine benutzerdefinierte Startvorlage mit deiner Amazon Machine Image (AMI)-ID. Konfiguriere anschließend die passenden Einstellungen für deinen HTTP-Proxy und die Umgebungsvariablen deines Clusters.

Wähle den Konfigurationsansatz basierend auf deiner AMI-Familie:

HTTP-Proxy für Amazon Linux 2-Knoten konfigurieren

Startvorlage erstellen

Öffne die Amazon Elastic Compute Cloud (Amazon EC2)-Konsole.
Wähle im Navigationsbereich Startvorlagen aus.
Wähle Startvorlage erstellen aus.
Gib unter Startvorlagenname einen Namen für deine Vorlage ein.
Wähle unter Anwendungs- und Betriebssystem-Images (Amazon Machine Image) deine Amazon Linux 2 AMI-ID aus.
Konfiguriere die folgenden Optionen:
Wähle für Instance-Typ den gewünschten Instance-Typ aus.
Wähle unter Schlüsselpaarname dein Amazon EC2-SSH-Schlüsselpaar aus.
Wähle unter Sicherheitsgruppen deine Sicherheitsgruppe aus.
Erweitere Erweiterte Details.

Gib für Benutzerdaten die folgende Konfiguration ein:

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

--==BOUNDARY==
Content-Type: text/cloud-boothook; charset="us-ascii"

#Set the proxy hostname and port
PROXY=XXXXXXX:3128
TOKEN=`curl -X PUT "http://[IP_ADDRESS]/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"`
MAC=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v -s http://[IP_ADDRESS]/latest/meta-data/mac/)
VPC_CIDR=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v -s http://[IP_ADDRESS]/latest/meta-data/network/interfaces/macs/$MAC/vpc-ipv4-cidr-blocks | xargs | tr ' ' ',')

#Create the containerd and sandbox-image systemd directory
mkdir -p /etc/systemd/system/containerd.service.d
mkdir -p /etc/systemd/system/sandbox-image.service.d

#[Optional] Configure yum to use the proxy
cloud-init-per instance yum_proxy_config cat << EOF >> /etc/yum.conf
proxy=http://$PROXY
EOF

#Set the proxy for future processes, and use as an include file
cloud-init-per instance proxy_config cat << EOF >> /etc/environment
http_proxy=http://$PROXY
https_proxy=http://$PROXY
HTTP_PROXY=http://$PROXY
HTTPS_PROXY=http://$PROXY
no_proxy=$VPC_CIDR,[IP_ADDRESS],[IP_ADDRESS],[IP_ADDRESS],.internal,.eks.amazonaws.com
NO_PROXY=$VPC_CIDR,[IP_ADDRESS],[IP_ADDRESS],[IP_ADDRESS],.internal,.eks.amazonaws.com
EOF

#Configure Containerd with the proxy
cloud-init-per instance containerd_proxy_config tee <<EOF /etc/systemd/system/containerd.service.d/http-proxy.conf >/dev/null
[Service]
EnvironmentFile=/etc/environment
EOF

#Configure sandbox-image with the proxy
cloud-init-per instance sandbox-image_proxy_config tee <<EOF /etc/systemd/system/sandbox-image.service.d/http-proxy.conf >/dev/null
[Service]
EnvironmentFile=/etc/environment
EOF

#Configure the kubelet with the proxy
cloud-init-per instance kubelet_proxy_config tee <<EOF /etc/systemd/system/kubelet.service.d/proxy.conf >/dev/null
[Service]
EnvironmentFile=/etc/environment
EOF

cloud-init-per instance reload_daemon systemctl daemon-reload

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

#!/bin/bash
set -o xtrace

#Set the proxy variables before running the bootstrap.sh script
set -a
source /etc/environment

#Run the bootstrap.sh script
B64_CLUSTER_CA=YOUR_CLUSTER_CA
API_SERVER_URL=API_SERVER_ENDPOINT

/etc/eks/bootstrap.sh EKS_CLUSTER_NAME --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL

--==BOUNDARY==--

Wähle Startvorlage erstellen aus.

Konfiguration überprüfen

Nachdem du deine verwaltete Knotengruppe mit der Startvorlage erstellt hast, überprüfe die Proxy-Konfiguration:

Führe den folgenden Befehl aus, um den Status deiner Knoten zu überprüfen:
```
kubectl get nodes -o wide
```
Um zu überprüfen, ob die Proxy-Umgebungsvariablen gesetzt sind, stelle eine Verbindung zu einem Knoten her und führe den folgenden Befehl aus:
```
systemctl show containerd | grep Environment
```

Die Ausgabe zeigt die für containerd konfigurierten Proxy-Umgebungsvariablen.

HTTP-Proxy für Amazon Linux 2023-Knoten konfigurieren

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

Amazon Linux 2023 führt einen neuen Knoten-Initialisierungsprozess nodeadm ein, der ein YAML-Konfigurationsschema verwendet. Für diesen Prozess läuft nodeadm in zwei Phasen: config und run. Die Phase nodeadm-config wird vor cloud-init ausgeführt, während nodeadm-run nach cloud-init läuft.

Während der Phase nodeadm-config ruft das System den Amazon EC2-Service auf, um Instance-Details abzurufen. Um den Amazon EC2-Aufruf zu verhindern, bevor du die Proxy-Einstellungen konfiguriert hast, verwende das Funktions-Gate InstanceIdNodeName in nodeadm.

IAM-Rolle für den Worker-Knoten erstellen

Erstelle eine neue AWS Identity and Access Management (IAM)-Rolle für Worker-Knoten mit den erforderlichen Richtlinien.
Verwende eine der folgenden Optionen, um der IAM-Rolle des Worker-Knotens die passenden Berechtigungen zu gewähren:

Variante 1: Einen EKS-Zugriffseintrag erstellen
Um einen Zugriffseintrag vom Typ EC2 zu erstellen, führe den folgenden AWS-CLI-Befehl create-access-entry aus:
```
aws eks create-access-entry --cluster-name EKS_CLUSTER_NAME --principal-arn WORKER_NODE_IAM_ROLE_ARN --type EC2
```
Hinweis: Ersetze EKS_CLUSTER_NAME durch den Namen deines Clusters. Ersetze WORKER_NODE_IAM_ROLE_ARN durch die ARN der IAM-Rolle deines Worker-Knotens.

Variante 2: aws-auth-ConfigMap aktualisieren
Füge die folgende Konfiguration im YAML-Format zu deiner aws-auth-ConfigMap hinzu:
```
- groups:
  - system:bootstrappers
  - system:nodes
  rolearn: ROLE_ARN
  username: system:node:{{SessionName}}
```
Hinweis: Ersetze ROLE_ARN durch die ARN der IAM-Rolle deines Worker-Knotens. Diese Konfiguration gewährt der IAM-Rolle des Worker-Knotens die erforderlichen Kubernetes-RBAC-Berechtigungen.

Startvorlage erstellen

Öffne die Amazon-EC2-Konsole.
Wähle im Navigationsbereich Startvorlagen aus.
Wähle Startvorlage erstellen aus.
Gib unter Startvorlagenname einen Namen für deine Vorlage ein.
Wähle unter Anwendungs- und Betriebssystem-Images (Amazon Machine Image) deine Amazon Linux 2023 AMI-ID aus.
Konfiguriere die folgenden Optionen:
Wähle für Instance-Typ den gewünschten Instance-Typ aus.
Wähle unter Schlüsselpaarname dein Amazon EC2-SSH-Schlüsselpaar aus.
Wähle unter Sicherheitsgruppen deine Sicherheitsgruppe aus.
Erweitere Erweiterte Details.

Gib für Benutzerdaten die folgende Konfiguration ein:

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

--==BOUNDARY==
Content-Type: text/cloud-boothook; charset="us-ascii"

#!/bin/bash

#Set the proxy hostname and port
PROXY=XXXXXXX:3128
TOKEN=`curl -X PUT "http://[IP_ADDRESS]/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"`
MAC=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v -s http://[IP_ADDRESS]/latest/meta-data/mac/)
VPC_CIDR=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v -s http://[IP_ADDRESS]/latest/meta-data/network/interfaces/macs/$MAC/vpc-ipv4-cidr-blocks | xargs | tr ' ' ',')

#[Optional] Configure yum to use the proxy
cloud-init-per instance yum_proxy_config cat << EOF >> /etc/yum.conf
proxy=http://$PROXY
EOF

#Set the proxy for future processes, and use as an include file
cloud-init-per instance proxy_config cat << EOF >> /etc/environment
http_proxy=http://$PROXY
https_proxy=http://$PROXY
HTTP_PROXY=http://$PROXY
HTTPS_PROXY=http://$PROXY
no_proxy=$VPC_CIDR,[IP_ADDRESS],[IP_ADDRESS],[IP_ADDRESS],.internal,.eks.amazonaws.com
NO_PROXY=$VPC_CIDR,[IP_ADDRESS],[IP_ADDRESS],[IP_ADDRESS],.internal,.eks.amazonaws.com
EOF

#Configure Containerd with the proxy
cloud-init-per instance containerd_proxy_config tee <<EOF /etc/systemd/system/containerd.service.d/http-proxy.conf >/dev/null
[Service]
EnvironmentFile=/etc/environment
EOF

#Configure the kubelet with the proxy
cloud-init-per instance kubelet_proxy_config tee <<EOF /etc/systemd/system/kubelet.service.d/proxy.conf >/dev/null
[Service]
EnvironmentFile=/etc/environment
EOF

cloud-init-per instance reload_daemon systemctl daemon-reload

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

---
apiVersion: node.eks.aws/v1alpha1
kind: NodeConfig
spec:
  featureGates:
    InstanceIdNodeName: true
  cluster:
    name: EKS_CLUSTER_NAME
    apiServerEndpoint: API_SERVER_ENDPOINT
    certificateAuthority: YOUR_CLUSTER_CA
    cidr: KUBERNETES_SERVICE_CIDR_RANGE

--==BOUNDARY==--

Hinweis: Ersetze XXXXXXX:3128 durch deinen Proxy-Host-Namen und Port. Ersetze YOUR_CLUSTER_CA durch deine Cluster-Zertifizierungsstelle (CA). Ersetze API_SERVER_ENDPOINT durch deinen Server-Endpunkt. Ersetze EKS_CLUSTER_NAME durch deinen Cluster-Namen. Ersetze KUBERNETES_SERVICE_CIDR_RANGE durch den Service-CIDR-Bereich deines Clusters. Wenn der Service-CIDR nicht in den Benutzerdaten angegeben ist, schlägt die Phase nodeadm-config fehl.

Wähle Startvorlage erstellen aus.

Konfiguration überprüfen

Nachdem du deine verwaltete Knotengruppe mit der Startvorlage erstellt hast, überprüfe die Proxy-Konfiguration:

Führe den folgenden Befehl aus, um den Status deiner Knoten zu überprüfen:
```
kubectl get nodes -o wide
```
Um zu überprüfen, ob die Proxy-Umgebungsvariablen gesetzt sind, stelle eine Verbindung zu einem Knoten her und führe den folgenden Befehl aus:
```
systemctl show containerd | grep Environment
```

Die Ausgabe zeigt die für containerd konfigurierten Proxy-Umgebungsvariablen.

HTTP-Proxy für Bottlerocket-Knoten konfigurieren

Startvorlage erstellen

Öffne die Amazon-EC2-Konsole.
Wähle im Navigationsbereich Startvorlagen aus.
Wähle Startvorlage erstellen aus.
Gib unter Startvorlagenname einen Namen für deine Vorlage ein.
Wähle unter Anwendungs- und Betriebssystem-Images (Amazon Machine Image) deine Bottlerocket AMI-ID aus.
Konfiguriere die folgenden Optionen:
Wähle für Instance-Typ den gewünschten Instance-Typ aus.
Wähle unter Schlüsselpaarname dein Amazon EC2-SSH-Schlüsselpaar aus.
Wähle unter Sicherheitsgruppen deine Sicherheitsgruppe aus.
Erweitere Erweiterte Details.

Gib für Benutzerdaten die folgende Konfiguration ein:

[settings.kubernetes]
"cluster-name" = "EKS_CLUSTER_NAME"
"api-server" = "API_SERVER_ENDPOINT"
"cluster-certificate" = "YOUR_CLUSTER_CA"

[settings.network]
no-proxy = ["VPC_CIDR_RANGE","[IP_ADDRESS]","[IP_ADDRESS]","[IP_ADDRESS]",".internal",".eks.amazonaws.com"]
https-proxy = "XXXXXXX:3128"

Hinweis: Ersetze XXXXXXX:3128 durch deinen Proxy-Host-Namen und Port. Ersetze YOUR_CLUSTER_CA durch deine Cluster-Zertifizierungsstelle (CA). Ersetze API_SERVER_ENDPOINT durch deinen Server-Endpunkt. Ersetze EKS_CLUSTER_NAME durch deinen Cluster-Namen. Ersetze VPC_CIDR_RANGE durch dein VPC-CIDR. Bottlerocket konfiguriert die Proxy-Einstellungen automatisch für den containerd- und kubelet-Dienst.

Um selbstsignierte Zertifikate zu deinen Bottlerocket-Instances hinzuzufügen, verwende die folgende Konfiguration im Abschnitt „Benutzerdaten“:

[settings.pki.proxy-bundle]
data="ENCODED_CA_DATA"
trusted=true

Hinweis: Ersetze ENCODED_CA_DATA durch die Base64-kodierten Zertifikatsdaten.

Um deine Zertifikatsdatei zu kodieren, führe den folgenden Befehl aus:

base64 -i FILE -w0

Wähle Startvorlage erstellen aus.

Konfiguration überprüfen

Nachdem du deine verwaltete Knotengruppe mit der Startvorlage erstellt hast, überprüfe die Proxy-Konfiguration:

Führe den folgenden Befehl aus, um den Status deiner Knoten zu überprüfen:
```
kubectl get nodes -o wide
```
Um die Proxy-Einstellungen zu überprüfen, verbinde dich über AWS Systems Manager Session Manager mit einem Bottlerocket-Knoten und führe den folgenden Befehl aus:
```
apiclient get settings.network
```

Die Ausgabe zeigt die für den Knoten konfigurierten Proxy-Einstellungen.

Verwaltete Knotengruppe erstellen

Nachdem du deine Startvorlage erstellt hast, erstelle eine neue verwaltete Knotengruppe, die diese benutzerdefinierte Startvorlage verwendet.

Weitere Informationen zum Erstellen verwalteter Knotengruppen mit Startvorlagen findest du unter Verwaltete Knoten mit Startvorlagen anpassen.

Proxy für vollständig private Cluster konfigurieren

Wichtig: Wenn du EKS Pod Identity-Zuordnungen mit einer Proxy-Konfiguration verwendest, musst du außerdem [IP_ADDRESS] (IPv4) oder [[IP_ADDRESS]] (IPv6) in deinen Umgebungsvariablen no_proxy/NO_PROXY eintragen.

Amazon EKS-Cluster mit privatem API-Serverendpunktzugriff, privaten Subnetzen und ohne Internetzugang erfordern zusätzliche Endpunkte. Wenn du die vorherige Konfiguration zum Erstellen eines Clusters verwendest, musst du Endpunkte für die folgenden Services erstellen und hinzufügen:

Amazon EC2
Amazon Elastic Container Registry zum Abrufen von Container-Images
Amazon Elastic Load Balancing für Application Load Balancers und Network Load Balancers
Amazon CloudWatch Logs
AWS Security Token Service, wenn du IAM-Rollen für Service-Konten verwendest
Amazon EKS Auth, wenn du Pod Identity-Zuordnungen verwendest
Amazon EKS

Nachdem du diese Endpunkte erstellt hast, konfiguriere die Variablen NO_PROXY und no_proxy in den Benutzerdaten deiner Amazon EC2-Startvorlage. Füge die öffentlichen Endpunkt-Subdomains hinzu, die spezifisch für deine AWS-Region und Services sind.

Zum Beispiel:

Für Amazon Simple Storage Service (Amazon S3):

Wenn sich dein Bucket in us-east-1 befindet, füge .s3.us-east-1.amazonaws.com hinzu.
Wenn sich dein Bucket in eu-west-1 befindet, füge .s3.eu-west-1.amazonaws.com hinzu.

Für Amazon EKS bei Verwendung von privatem Endpunktzugriff:

Wenn sich dein Cluster in us-east-1 befindet, füge .us-east-1.eks.amazonaws.com hinzu.
Wenn sich dein Cluster in eu-west-1 befindet, füge .eu-west-1.eks.amazonaws.com hinzu.

Hinweis: Ersetze die Regionsbezeichner durch die AWS-Region, in der du deine Ressourcen bereitgestellt hast, und füge diese Endpunkte sowohl zu NO_PROXY als auch no_proxy hinzu. Abhängig vom Workload und den Add-ons deines Clusters kannst du weitere Services zu deiner Proxy-Konfiguration hinzufügen.

Proxy für öffentliche Cluster konfigurieren

Hinweis: Wenn du eine andere Konfiguration hast, sind diese Schritte optional.

Wenn du Traffic aus dem Cluster über einen HTTP-Proxy ins Internet leitest und dein Amazon EKS-Endpunkt öffentlich ist, führe die folgende Aufgabe aus.

Erstelle eine ConfigMap, um die Umgebungsvariablen zu konfigurieren:

apiVersion: v1
kind: ConfigMap
metadata:
  name: proxy-environment-variables
  namespace: kube-system

data:
  HTTP_PROXY: http://XXXXXXX:3128
  HTTPS_PROXY: http://XXXXXXX:3128
  NO_PROXY: KUBERNETES_SERVICE_CIDR_RANGE,[IP_ADDRESS],[IP_ADDRESS],VPC_CIDR_RANGE,[IP_ADDRESS],.internal,.eks.amazonaws.com,ec2.us-east-1.amazonaws.com
  no_proxy: KUBERNETES_SERVICE_CIDR_RANGE,[IP_ADDRESS],[IP_ADDRESS],VPC_CIDR_RANGE,[IP_ADDRESS],.internal,.eks.amazonaws.com,ec2.us-east-1.amazonaws.com

Hinweis: Ersetze KUBERNETES_SERVICE_CIDR_RANGE und VPC_CIDR_RANGE durch die Werte für deine CIDR-Bereiche. Nachdem du die VPC-Endpunkte (Amazon EKS und Amazon EC2) erstellt hast, füge AWS-Service-Endpunkte zu NO_PROXY und no_proxy hinzu.

Wende die ConfigMap an:

kubectl apply -f proxy-configmap.yaml

aws-node und kube-proxy konfigurieren

Um die HTTP-Proxy-Konfiguration für aws-node und kube-proxy festzulegen, führe die folgenden Befehle aus:

kubectl patch -n kube-system -p '{ "spec": {"template":{ "spec": { "containers": [ { "name": "aws-node", "envFrom": [ { "configMapRef": {"name": "proxy-environment-variables"} } ] } ] } } } }' daemonset aws-node

kubectl patch -n kube-system -p '{ "spec": {"template":{ "spec": { "containers": [ { "name": "kube-proxy", "envFrom": [ { "configMapRef": {"name": "proxy-environment-variables"} } ] } ] } } } }' daemonset kube-proxy

Proxy-Konfiguration überprüfen

Um zu überprüfen, ob die Proxy-Konfiguration korrekt funktioniert, führe die folgenden Schritte aus:

Führe den folgenden Befehl aus, um den Status deiner Knoten zu überprüfen:
```
kubectl get nodes -o wide
```

Um die Pod-Konnektivität über den Proxy zu testen, führe die folgenden Befehle aus:

kubectl run test-pod --image=amazonlinux:2 --restart=Never -- sleep 300
kubectl get pods -A

Überprüfe die Proxy-Protokolle auf zusätzliche Informationen zur Konnektivität deiner Knoten. Die Protokolle sollten erfolgreiche Verbindungen (TCP_TUNNEL/200) zu Container-Registry-Endpunkten anzeigen.
Beispielausgabe:

192.168.100.114 TCP_TUNNEL/200 6230 CONNECT registry-1.docker.io:443 - HIER_DIRECT/XX.XX.XX.XX -
192.168.100.114 TCP_TUNNEL/200 10359 CONNECT auth.docker.io:443 - HIER_DIRECT/XX.XX.XX.XX -

Relevanter Inhalt

Wie automatisiere ich die HTTP-Proxy-Konfiguration für Amazon-EKS-Worker-Knoten mit Docker?
AWS OFFICIALAktualisiert vor 2 Jahren
Wie automatisiere ich die HTTP-Proxy-Konfiguration für Amazon-EKS mit Amazon Linux 2023-Worker-Knoten?
AWS OFFICIALAktualisiert vor 5 Monaten
Wie kann ich die Bereinigung von Docker-Containern und -Images in Amazon ECS automatisieren?
AWS OFFICIALAktualisiert vor 4 Jahren
Wie kann ich die CloudWatch-Protokolle für die erweiterte Überwachung filtern, um automatisierte benutzerdefinierte Metriken für Amazon RDS zu generieren?
AWS OFFICIALAktualisiert vor 3 Jahren

Wie kann ich die Konfiguration des HTTP-Proxys für Amazon EKS-Container-Knoten automatisieren?

Kurzbeschreibung

Lösung

HTTP-Proxy für Amazon Linux 2-Knoten konfigurieren

HTTP-Proxy für Amazon Linux 2023-Knoten konfigurieren

HTTP-Proxy für Bottlerocket-Knoten konfigurieren

Verwaltete Knotengruppe erstellen

Proxy für vollständig private Cluster konfigurieren

Proxy für öffentliche Cluster konfigurieren

Proxy-Konfiguration überprüfen

Ähnliche Informationen

Relevanter Inhalt