OCI Load Balancer für Kubernetes-Services vom Typ LoadBalancer bereitstellen

oci.oraclecloud.com/load-balancer-type: "lb"

Beachten Sie, dass lb der Standardwert der Annotation oci.oraclecloud.com/load-balancer-type ist. Wenn Sie die Annotation nicht explizit in die Servicedefinition aufnehmen, wird der Standardwert der Annotation verwendet.

Beispiel: Beachten Sie die folgende Konfigurationsdatei: nginx_lb.yaml. Sie definiert ein Deployment (kind: Deployment) für die nginx-App, gefolgt von einer Definition eines Service vom Typ LoadBalancer (type: LoadBalancer), der HTTP-Traffic an Port 80 für die nginx-App verteilt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Der erste Teil der Konfigurationsdatei definiert ein Nginx-Deployment, wobei angefordert wird, dass es auf 3 Pods gehostet wird, auf denen das nginx:latest-Image ausgeführt wird. Außerdem muss der Traffic zu den Containern an Port 80 akzeptiert werden.

Der zweite Teil der Konfigurationsdatei definiert den Nginx-Service, der mit dem LoadBalancer-Typ den Nginx-Traffic an Port 80 auf die verfügbaren Pods verteilt.

Um bei bestehender Verbindung mit dem Kubernetes-Cluster das Deployment und den Service zu erstellen, die in nginx_lb.yaml definiert sind, geben Sie folgenden Befehl ein:

kubectl apply -f nginx_lb.yaml

Nach erfolgreicher Erstellung des Deployments und des Load Balancers gibt dieser Befehl Folgendes aus:

deployment "my-nginx" created
service "my-nginx-svc" created

Es kann einige Minuten dauern, bis der Load Balancer vom Status "Ausstehend" zur vollständigen Betriebsbereitschaft wechselt. Sie können den aktuellen Status Ihres Clusters anzeigen, indem Sie Folgendes eingeben:

kubectl get all

Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:

NAME                                  READY     STATUS    RESTARTS   AGE
po/my-nginx-431080787-0m4m8           1/1       Running   0          3m
po/my-nginx-431080787-hqqcr           1/1       Running   0          3m
po/my-nginx-431080787-n8125           1/1       Running   0          3m

NAME               CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
svc/kubernetes     203.0.113.1     <NONE>           443/TCP        3d
svc/my-nginx-svc   203.0.113.7     192.0.2.22       80:30269/TCP   3m

NAME                      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deploy/my-nginx           3         3         3            3           3m

NAME                            DESIRED   CURRENT   READY     AGE
rs/my-nginx-431080787           3         3         3         3m

Die Ausgabe zeigt, dass das my-nginx-Deployment auf 3 Pods (den po/my-nginx-Einträgen) ausgeführt wird, dass der Load Balancer ausgeführt wird (svc/my-nginx-svc) und über eine externe IP (192.0.2.22) verfügt, mit der Clients eine Verbindung zu der auf den Pods bereitgestellten App herstellen können.

Wenn Sie einen Oracle Cloud Infrastructure-(OCI-)Load Balancer für einen Kubernetes-Service vom Typ LoadBalancer bereitstellen, können Sie ihn so konfigurieren, dass er SSL-/TLS-Traffic beendet. Diese Konfiguration, die oft als Frontend-SSL bezeichnet wird, stellt sicher, dass verschlüsselter Datenverkehr aus dem Internet beim Load Balancer entschlüsselt wird, bevor er an Worker-Knoten weitergeleitet wird.

Durch die Implementierung einer SSL-Beendigung auf Load-Balancer-Ebene wird der intensive Entschlüsselungsprozess von Anwendungspods ausgelagert, wodurch die Zertifikatsverwaltung vereinfacht und die Backend-Performance verbessert wird.

Beachten Sie, dass Sie die vollständige Point-to-Point-SSL-Verschlüsselung zwischen Clients und Anwendungspods implementieren können, die auf Worker-Knoten ausgeführt werden. Dazu konfigurieren Sie die SSL-Beendigung am Load Balancer (wie in diesem Abschnitt beschrieben) und implementieren Backend-SSL zwischen dem Load Balancer und den Worker-Knoten (siehe SSL/TLS zwischen Load Balancer und Worker-Knoten implementieren (Backend-SSL)).

oci.oraclecloud.com/oci-load-balancer-ssl-config: '{"CipherSuiteName":"<cipher-suite-name>", "Protocols":["<tls-version>"]}'

oci.oraclecloud.com/oci-load-balancer-ssl-config: '{"CipherSuiteName":"oci-default-http2-tls-12-13-ssl-cipher-suite-v1", "Protocols":["TLSv1.2", "TLSv1.3"]}'

Wenn Kubernetes Engine einen Load Balancer für einen Kubernetes-Service vom Typ LoadBalancer bereitstellt, können Sie angeben, dass Sie SSL zwischen dem Load Balancer und den Backend-Servern (Worker-Knoten) im Backend-Set implementieren möchten. Diese Konfiguration wird als Backend-SSL bezeichnet. Um Backend-SSL zu implementieren, verknüpfen Sie ein SSL-Zertifikat mit dem Backend-Set des Load Balancers.

Beachten Sie, dass Sie die vollständige Point-to-Point-SSL-Verschlüsselung zwischen Clients und Anwendungspods implementieren können, die auf Worker-Knoten ausgeführt werden. Dazu verknüpfen Sie ein SSL-Zertifikat mit dem Backend-Set des Load Balancers (wie in diesem Abschnitt beschrieben), und erstellen einen Load Balancer mit SSL-Beendigung (siehe SSL/TLS beim Load Balancer beenden (Frontend-SSL)).

Während die Frontend-SSL-Beendigung die Verbindung zwischen dem Client und dem Load Balancer sichert, sichert Backend-SSL die Verbindung zwischen dem Load Balancer und den Worker-Knoten. Diese Konfiguration stellt sicher, dass der Datenverkehr auch während der Übertragung durch das interne virtuelle Cloud-Netzwerk (VCN) verschlüsselt bleibt. Dadurch erhalten Sie eine zusätzliche Verteidigungsebene.

Wenn Sie Backend-SSL implementieren, entschlüsselt der Load Balancer eingehenden Traffic mit einem Frontend-Zertifikat, führt alle erforderlichen Layer-7-Inspektionen oder -Routing aus und verschlüsselt den Traffic dann erneut, bevor er an die Zielpods gesendet wird. Dies ist eine gängige Anforderung für Umgebungen mit hoher Sicherheit, bei denen der Klartextverkehr bei jedem Hop eingeschränkt wird.

oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config: '{"CipherSuiteName":"<cipher-suite-name>", "Protocols":["<tls-version>"]}'

oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config: '{"CipherSuiteName":"oci-default-http2-tls-12-13-ssl-cipher-suite-v1", "Protocols":["TLSv1.2", "TLSv1.3"]}'

Die Ausprägung eines Oracle Cloud Infrastructure Load Balancers gibt die maximale Gesamtbandbreite an (d.h. Ingress plus Egress). Standardmäßig werden Load Balancer mit einer Ausprägung von 100 Mbit/s erstellt. Andere Ausprägungen sind verfügbar, einschließlich 400 Mbit/s und 8000 Mbit/s.

Um eine alternative Ausprägung für einen Load Balancer anzugeben, fügen Sie die folgende Annotation im Metadatenabschnitt der Manifestdatei hinzu:

service.beta.kubernetes.io/oci-load-balancer-shape: <value>

Hierbei ist value die Bandbreite der Ausprägung (Beispiel: 100 Mbit/s, 400 Mbit/s, 8000 Mbit/s).

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-shape: 400Mbps
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

In der Region für die angegebene Ausprägung muss eine ausreichende Quota für den Load Balancer verfügbar sein. Geben Sie den folgenden kubectl-Befehl ein, um sicherzustellen, dass das erfolgreiche Erstellen des Load Balancers nicht aufgrund einer unzureichenden Quota verhindert wurde:

kubectl describe service <service-name>

Beachten Sie, dass Oracle empfiehlt, Kubernetes-Services des Typs LoadBalancer als kosteneffiziente flexible Load Balancer und nicht als (dynamische) Load Balancer mit fester Ausprägung zu implementieren (siehe Flexible Load Balancer-Ausprägungen angeben).

Die Ausprägung eines Oracle Cloud Infrastructure Load Balancers gibt die maximale Gesamtbandbreite an (d.h. Ingress plus Egress). Wie unter Alternative Load-Balancer-Ausprägungen angeben beschrieben, können Sie verschiedene Ausprägungen für Load Balancer angeben.

Darüber hinaus können Sie eine flexible Ausprägung für einen Oracle Cloud Infrastructure Load Balancer angeben, indem Sie eine minimale und eine maximale Bandbreite für den Load Balancer definieren.

Um eine flexible Ausprägung für einen Load Balancer anzugeben, fügen Sie die folgenden Annotationen im Metadatenabschnitt der Manifestdatei hinzu:

service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "<min-value>"
service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "<max-value>"

Hierbei gilt:

• "<min-value>" ist die minimale Bandbreite für den Load Balancer in Mbps (z.B. "10")
• "<max-value>" ist die maximale Bandbreite für den Load Balancer in Mbps (z.B. "100")

Hinweis: Die Angabe von Bandbreitenwerten für flexible Load-Balancer-Ausprägungen enthält keine Maßeinheit (im Gegensatz zu vordefinierten Ausprägungen). Geben Sie beispielsweise die minimale Bandbreite als 10 und nicht als 10Mbps an.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Beim Provisioning eines Oracle Cloud Infrastructure-Load Balancers für einen Kubernetes-Service des Typs LoadBalancer können Sie die maximal zulässige Leerlaufzeit (in Sekunden) zwischen zwei aufeinanderfolgenden Empfangsvorgängen oder zwei aufeinanderfolgenden Sendevorgängen zwischen Client- und Backend-Servern angeben.

Um explizit eine maximale Leerlaufzeit anzugeben, fügen Sie die folgende Annotation im Metadatenabschnitt der Manifestdatei hinzu:

service.beta.kubernetes.io/oci-load-balancer-connection-idle-timeout: <value>

Hierbei gibt value die Anzahl der Sekunden an.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-connection-idle-timeout: 100
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Wenn Sie nicht explizit eine maximale Leerlaufzeit angeben, wird ein Standardwert verwendet. Der Standardwert hängt vom Listener-Typ ab:

• Für TCP-Listener beträgt die standardmäßige maximale Leerlaufzeit 300 Sekunden.
• Für HTTP-Listener beträgt die maximale Standardleerlaufzeit 60 Sekunden.

Beim Provisioning eines Oracle Cloud Infrastructure-Load Balancers für einen Kubernetes-Service vom Typ LoadBalancer können Sie die maximale Anzahl gleichzeitiger Verbindungen angeben, die der Load Balancer für Backend-Server (Worker-Knoten) im Backend-Set herstellen darf.

Um die maximale Anzahl gleichzeitiger Verbindungen, die zwischen dem Load Balancer und jedem einzelnen Backend-Server im Backend-Set zulässig sind, explizit anzugeben, fügen Sie im Metadatenabschnitt der Manifestdatei die folgende Anmerkung hinzu:

oci-load-balancer.oraclecloud.com/backendset-backend-max-connections: "<value>"

wobei <value> wie folgt ein gültiger Wert für die Anzahl der zulässigen Verbindungen ist:

• Eine Zahl zwischen "256" und "65535" (einschließlich). Wenn Sie eine Zahl außerhalb dieses Bereichs angeben (außer 0), wird ein Fehler zurückgegeben.
• "0". Wenn Sie 0 als maximale Anzahl zulässiger Verbindungen angeben, ist eine unbegrenzte Anzahl von Verbindungen zwischen dem Load Balancer und jedem einzelnen Backend-Server im Backend-Set zulässig.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  annotations:
    oci-load-balancer.oraclecloud.com/backendset-backend-max-connections: "256"
spec:
  selector:
    app: nginx
  type: LoadBalancer
  ports:
    - name: http
      port: 80
      targetPort: 80

Beachten Sie Folgendes:

• Die Zahl, die Sie für die Annotation angeben, wird nicht nur als Wert der Eigenschaft backendMaxConnections des Backend-Sets verwendet, sondern wird auch von jedem einzelnen Backend-Server als Wert der Eigenschaft maxConnections geerbt. Daher wird die angegebene Anzahl als die Anzahl der Verbindungen verwendet, die zwischen dem Load Balancer und jedem einzelnen Backend-Server im Backend-Set zulässig sind, und nicht als die Gesamtzahl der Verbindungen, die zwischen dem Load Balancer und dem Backend-Set zulässig sind.
• Wenn Sie die Annotation nicht in das Manifest aufnehmen (oder anschließend die Annotation entfernen), ist eine unbegrenzte Anzahl von Verbindungen zwischen dem Load Balancer und jedem Backend-Server zulässig.
• Zugehörige Informationen zur Angabe der maximalen Anzahl gleichzeitiger Verbindungen zum Listener des Load Balancers, die von derselben Ursprungs-IP-Adresse zulässig sind, finden Sie unter Maximale Listener-Verbindungsregeln angeben.

Wenn Kubernetes Engine einen Oracle Cloud Infrastructure-Load Balancer für einen Kubernetes-Service vom Typ LoadBalancer bereitstellt, können Sie die maximale Anzahl gleichzeitiger Verbindungen zum Listener des Load Balancers angeben, die von derselben Ursprungs-IP-Adresse zulässig sind. Mit einer Annotation definieren Sie einen standardmäßigen maximalen Listener-Verbindungswert, der für alle IP-Adressen gilt. Die Annotation definiert eine Regel für die maximale Listener-Verbindung für den Load Balancer. Wenn Sie diesen Standardhöchstwert nicht festlegen, gibt es keinen Grenzwert für die Anzahl der Verbindungen, die eine IP-Adresse an den Listener herstellen kann.

Weitere Informationen zu den Regeln für die maximale Listener-Verbindung finden Sie unter Max. Listener-Verbindungsregeln in der OCI Load Balancer-Dokumentation.

Um die maximale Anzahl gleichzeitiger Listener-Verbindungen anzugeben, die von derselben Ursprungs-IP-Adresse zulässig sind, fügen Sie die Annotation oci.oraclecloud.com/oci-load-balancer-rule-sets im Metadatenabschnitt der Manifestdatei hinzu. Beachten Sie, dass Sie den Wert der Annotation wie folgt als formatierte JSON angeben:

oci.oraclecloud.com/oci-load-balancer-rule-sets: |
  {
    "<rule-set-name>": {
      "items": [
        {
          "action": "IP_BASED_MAX_CONNECTIONS",
          "maxConnectionsPerIp": <value>
        }
      ]
    }
  }

Hierbei gilt:

• <rule-set-name> ist die von Ihnen gewählte Bezeichnung für das Regelset (zwischen 1 und 32 Zeichen). Beispiel: IpLimitRuleSet .
• <value> ist die maximale Anzahl gleichzeitiger Listener-Verbindungen, die von derselben Ursprungs-IP-Adresse zulässig sind.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    oci.oraclecloud.com/oci-load-balancer-rule-sets: |
      {
        "IpLimitRuleSet": {
          "items": [
            {
              "action": "IP_BASED_MAX_CONNECTIONS",
              "maxConnectionsPerIp": 20
            }
          ]
        }
      }
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Diese Konfiguration erstellt ein Regelset für die maximale Listener-Verbindung namens IpLimitRuleSet, das jede ursprüngliche IP-Adresse auf maximal 20 nebenläufige Verbindungen beschränkt.

Um anschließend die maximale Anzahl gleichzeitiger Verbindungen zu ändern, aktualisieren Sie die Annotation oci.oraclecloud.com/oci-load-balancer-rule-sets, und wenden Sie das Manifest erneut an.

Wenn Kubernetes Engine einen Load Balancer für einen Kubernetes-Service vom Typ LoadBalancer bereitstellt, können Sie die maximale Größe des HTTP-Headers angeben, der von den Listenern des Load Balancers akzeptiert wird. Sie geben die maximale Größe des HTTP-Headers an, indem Sie mit einer Annotation die Größe (in KB) des Buffers angeben, der zum Lesen des Headers verwendet wird. Die zulässigen Werte für die Puffergröße sind 8, 16, 32 und 64. Die Annotation definiert eine HTTP-Headerregel für den Load Balancer. Die HTTP-Headerregel gilt für alle Listener des Load Balancers auf allen Ports.

Weitere Informationen zu HTTP-Headerregeln finden Sie unter HTTP-Headerregeln in der OCI Load Balancer-Dokumentation.

Um die maximale Größe des HTTP-Headers anzugeben, der von den Listenern des Load Balancers akzeptiert wird, fügen Sie die Annotation oci.oraclecloud.com/oci-load-balancer-rule-sets im Metadatenabschnitt der Manifestdatei hinzu. Beachten Sie, dass Sie den Wert der Annotation wie folgt als formatierte JSON angeben:

oci.oraclecloud.com/oci-load-balancer-rule-sets:  |
      {
        "<rule-set-name>": {
          "items": [
            {
              "action": "HTTP_HEADER",
              "httpLargeHeaderSizeInKB": <value>
            }
          ]
        }
      }

Hierbei gilt:

• <rule-set-name> ist der Name Ihrer Wahl für das Regelset (zwischen 1 und 32 Zeichen). Beispiel: header-size.
• <value> ist die maximale Größe des HTTP-Headers in KB. Dabei handelt es sich um 8, 16, 32 oder 64.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    oci.oraclecloud.com/oci-load-balancer-rule-sets: |
      {
        "header-size": {
          "items": [
            {
              "action": "HTTP_HEADER",
              "httpLargeHeaderSizeInKB": 16
            }
          ]
        }
      }
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Um anschließend die maximale Größe des HTTP-Headers zu ändern, aktualisieren Sie die Annotation oci.oraclecloud.com/oci-load-balancer-rule-sets, und wenden Sie das Manifest erneut an.

Wenn die Kubernetes-Engine einen Load Balancer für einen Kubernetes-Service des Typs LoadBalancer bereitstellt, können Sie den vom Listener akzeptierten Traffictyp definieren, indem Sie das Protokoll angeben, auf dem der Listener Verbindungsanforderungen akzeptiert.

Wenn Sie nicht explizit ein Protokoll angeben, wird "TCP" als Standardwert verwendet.

Um das Load Balancer Listener-Protokoll explizit anzugeben, wenn Kubernetes Engine einen Load Balancer für einen Kubernetes-Service des Typs LoadBalancer bereitstellt, fügen Sie die folgende Anmerkung im Metadatenabschnitt der Manifestdatei hinzu:

service.beta.kubernetes.io/oci-load-balancer-backend-protocol: <value>

Hierbei ist <value> das Protokoll, das den Traffictyp definiert, der vom Listener akzeptiert wird. Beispiel: "HTTP". Gültige Protokolle sind "HTTP", "TCP" und "GRPC".

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-backend-protocol: "HTTP"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Wenn Sie GRPC als Protokoll angeben, müssen Sie Folgendes konfigurieren:

• Frontend SSL mit den Annotationen service.beta.kubernetes.io/oci-load-balancer-ssl-ports, oci.oraclecloud.com/oci-load-balancer-ssl-listener-config und service.beta.kubernetes.io/oci-load-balancer-tls-secret. Weitere Informationen finden Sie unter SSL/TLS beim Load Balancer beenden (Frontend-SSL).
• Backend-SSL mit den Annotationen oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config und service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret. Weitere Informationen finden Sie unter SSL/TLS zwischen Load Balancer und Worker-Knoten implementieren (Backend-SSL).

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: hello-grpc-service
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-ssl-ports: "443"
    service.beta.kubernetes.io/oci-load-balancer-tls-secret: ssl-certificate-secret
    service.beta.kubernetes.io/oci-load-balancer-backend-protocol: "GRPC"
    oci.oraclecloud.com/oci-load-balancer-listener-ssl-config: '{"CipherSuiteName":"oci-default-http2-ssl-cipher-suite-v1", "Protocols":["TLSv1.2"]}'
    oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config: '{"CipherSuiteName":"oci-default-http2-ssl-cipher-suite-v1", "Protocols":["TLSv1.2"]}'
    service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret: ca-ser-secret
spec:
  type: LoadBalancer
  selector:
    app: hello-grpc
  ports:
    - port: 443
      name: grpc
      targetPort: 50051

Mit dem Feature zur Verwaltung von Sicherheitslisten können Sie konfigurieren, wie Sicherheitslistenregeln für einen Oracle Cloud Infrastructure-Load Balancer verwaltet werden, den Kubernetes Engine für einen Kubernetes-Service des Typs LoadBalancer bereitstellt. Dieses Feature ist hilfreich, wenn Sie neu in Kubernetes sind, oder für einfache Deployments.

Um anzugeben, wie Sicherheitslisten vom Kubernetes-Feature zur Verwaltung von Sicherheitslisten verwaltet werden, wenn die Kubernetes-Engine einen Load Balancer für einen Kubernetes-Service des Typs LoadBalancer bereitstellt, fügen Sie im Metadatenabschnitt der Manifestdatei die folgende Annotation hinzu:

service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode: <value>

Hierbei ist <value> einer der folgenden Werte:

• "None": (empfohlen) Es ist keine Verwaltung der Sicherheitsliste aktiviert. Sie müssen eine Sicherheitsregel einrichten, die eingehenden Traffic an die entsprechenden Ports für Knotenportbereiche, den Port für den kube-proxy-Zustand und die Health-Check-Portbereiche zulässt. Außerdem müssen Sie Sicherheitsregeln einrichten, damit eingehender Traffic an Load Balancer zulässig ist (siehe Sicherheitsregeln für Load Balancer und Network Load Balancer).
• "All": (Standard) Alle erforderlichen Sicherheitslistenregeln für Load-Balancer-Services werden verwaltet.
• "Frontend": Nur Sicherheitslistenregeln für Ingress für Load-Balancer-Services werden verwaltet. Sie müssen eine Sicherheitsregel einrichten, die eingehenden Traffic an die entsprechenden Ports für Knotenportbereiche, den Port für den kube-proxy-Zustand und die Health-Check-Portbereiche zulässt.

Oracle empfiehlt, dass Sie service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode explizit auf None setzen.

Wenn Sie in Clustern mit verwalteten Knoten nicht explizit einen Verwaltungsmodus angeben oder einen ungültigen Wert angeben, werden alle Sicherheitslistenregeln verwaltet (entspricht "All"). Beachten Sie, dass in diesem Fall die Kubernetes-Engine eine Sicherheitsregel erstellt, die eingehenden Traffic von 0.0.0.0/0 (oder von den in der Manifestdatei angegebenen Quellportbereichen) zu Listener-Ports zulässt. In Clustern mit virtuellen Knoten ist die Sicherheitslistenverwaltung nie aktiviert, und Sie müssen Sicherheitsregeln immer manuell konfigurieren (entspricht "None").

Beachten Sie, dass die Anzahl der Ingress- und Egress-Regeln, die in einer Sicherheitsliste zulässig sind, begrenzt ist (siehe Limits für Sicherheitslisten). Wenn die Anzahl der Ingress- oder Egress-Regeln das Limit überschreitet und <value> auf "All" oder "Frontend" gesetzt ist, verläuft das Erstellen oder Aktualisieren des Load Balancers nicht erfolgreich.

Beispiel:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode: "Frontend"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx