Provisionnement des équilibreurs de charge OCI pour les services Kubernetes de type LoadBalancer

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

Notez que lb est la valeur par défaut de l'annotation oci.oraclecloud.com/load-balancer-type. Si vous n'incluez pas explicitement l'annotation dans la définition du service, la valeur par défaut de l'annotation est utilisée.

Par exemple, considérons le fichier de configuration suivant, nginx_lb.yaml. Il définit un déploiement (kind: Deployment) pour l'application nginx, suivi d'une définition de service de type LoadBalancer (type: LoadBalancer) qui équilibre le trafic HTTP sur le port 80 pour l'application nginx.

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

La première partie du fichier de configuration définit un déploiement de Nginx, demandant qu'il soit hébergé sur 3 pods exécutant l'image nginx:latest, et qu'il accepte le trafic vers les conteneurs sur le port 80.

La deuxième partie du fichier de configuration définit le service Nginx, qui utilise le type LoadBalancer pour équilibrer le trafic Nginx sur le port 80 entre les pods disponibles.

Pour créer le déploiement et le service définis dans nginx_lb.yaml lorsque vous êtes connecté à votre grappe Kubernetes, entrez la commande suivante :

kubectl apply -f nginx_lb.yaml

Cette commande affiche le résultat suivant lorsque la création du déploiement et de l'équilibreur de charge aboutit :

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

L'équilibreur de charge peut rester en attente pendant quelques minutes avant d'être totalement opérationnel. Vous pouvez voir l'état courant de votre grappe en entrant :

kubectl get all

La sortie de la commande ci-dessus montre l'état courant :

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

Cette sortie indique que le déploiement my-nginx s'exécute sur 3 pods (les entrées po/my-nginx), que l'équilibreur de charge est en cours d'exécution (svc/my-nginx-svc) et qu'il possède une adresse IP externe (192.0.2.22) que les clients peuvent utiliser pour se connecter à l'application déployée sur les pods.

Lorsque Kubernetes Engine provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, vous pouvez spécifier que vous voulez résilier le protocole SSL dans l'équilibreur de charge. Cette configuration est appelée SSL frontal. Pour mettre en oeuvre le protocole SSL frontal, vous définissez un module d'écoute sur un port tel que 443 et vous associez un certificat SSL au module d'écoute.

Notez que vous pouvez mettre en oeuvre le chiffrement SSL point à point complet entre les clients et les pods d'application s'exécutant sur les noeuds de travail. Pour ce faire, créez un équilibreur de charge avec terminaison SSL (comme décrit dans cette section) et associez également un certificat SSL au jeu dorsal de l'équilibreur de charge (voir Mise en oeuvre du protocole SSL/TLS entre l'équilibreur de charge et les noeuds de travail).

Cet exemple fournit une description détaillée de la configuration et de la création d'un équilibreur de charge avec prise en charge de SSL.

Voyez le fichier de configuration suivant, nginx-demo-svc-ssl.yaml, qui définit un déploiement de Nginx et l'expose au moyen d'un équilibreur de charge qui dessert http sur le port 80 et https sur le port 443. Cet exemple crée un équilibreur de charge Oracle Cloud Infrastructure en définissant un service de type LoadBalancer (type: LoadBalancer).

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
---
kind: Service
apiVersion: v1
metadata:
  name: nginx-service
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-ssl-ports: "443"
    oci.oraclecloud.com/oci-load-balancer-listener-ssl-config: '{"CipherSuiteName":"oci-default-http2-tls-12-13-ssl-cipher-suite-v1", "Protocols":["TLSv1.3"]}'
    service.beta.kubernetes.io/oci-load-balancer-tls-secret: ssl-certificate-secret
spec:
  selector:
    app: nginx
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 80
  - name: https
    port: 443
    targetPort: 80

Les annotations de l'équilibreur de charge sont particulièrement importantes, comme décrit ici.

Les ports sur lesquels le trafic HTTP doit être pris en charge sont définis par la valeur de l'annotation service.beta.kubernetes.io/oci-load-balancer-ssl-ports. Vous pouvez déclarer plusieurs ports SSL en utilisant une liste séparée par des virgules pour la valeur de l'annotation. Par exemple, vous pouvez régler la valeur de l'annotation à "443, 3000" pour prendre en charge SSL sur les ports 443 et 3000.

La suite de chiffrement à utiliser avec l'équilibreur de charge est définie par la valeur de l'annotation oci.oraclecloud.com/oci-load-balancer-listener-ssl-config. Les suites de chiffrement déterminent la sécurité, la compatibilité et la vitesse du trafic HTTPS (pour plus d'informations, voir Suites de chiffrement pour les équilibreurs de charge). Vous spécifiez à la fois le nom de la suite de chiffrement (par exemple, oci-default-http2-TLS-12-13-ssl-cipher-suite-v1) et la version TLS (par exemple, TLSv1.3). Vous pouvez spécifier une suite de chiffrement prédéfinie préconfigurée par Oracle Cloud Infrastructure (voir Suites de chiffrement prédéfinies de l'équilibreur de charge) ou une suite de chiffrement que vous avez créée vous-même. Si vous n'incluez pas l'annotation oci.oraclecloud.com/oci-load-balancer-listener-ssl-config, mais que vous incluez l'annotation service.beta.kubernetes.io/oci-load-balancer-tls-secret, la suite de chiffrement oci-default-ssl-cipher-suite-v1 est utilisée.

La clé secrète TLS obligatoire, ssl-certificate-secret, doit être créée dans Kubernetes. Cet exemple crée et utilise un certificat auto-signé. Toutefois, dans un environnement de production, le scénario le plus courant consiste à utiliser un certificat public signé par une autorité de certification.

La commande suivante crée un certificat auto-signé, tls.crt, avec la clé correspondante, tls.key :

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=nginxsvc/O=nginxsvc"

Maintenant que vous avez créé le certificat, vous devez le stocker avec sa clé dans Kubernetes, en tant que clé secrète. Le nom de la clé secrète doit correspondre au nom de l'annotation service.beta.kubernetes.io/oci-load-balancer-tls-secret dans la définition de l'équilibreur de charge. Utilisez la commande suivante pour créer une clé secrète TLS dans Kubernetes, dont les valeurs de clé et de certificat sont définies par --key et --cert, respectivement.

kubectl create secret tls ssl-certificate-secret --key tls.key --cert tls.crt

Vous devez créer la clé secrète Kubernetes avant de créer le service, car celui-ci référence cette clé dans sa définition. Créez le service au moyen de la commande suivante :

kubectl create -f manifests/demo/nginx-demo-svc-ssl.yaml

Observez le service et attendez qu'une adresse IP publique (EXTERNAL IP) soit affectée au service Nginx (nginx-service) en entrant :

kubectl get svc --watch

La sortie de la commande ci-dessus montre l'adresse IP de l'équilibreur de charge à utiliser pour la connexion au service.

NAME            CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
nginx-service   192.0.2.1      198.51.100.1     80:30274/TCP   5m

L'équilibreur de charge est en cours d'exécution, ce qui signifie que le service est désormais accessible comme suit :

• à l'aide de http, en entrant :

  curl http://198.51.100.1

• à l'aide de https, en entrant :

  curl --insecure https://198.51.100.1

  L'indicateur "--insecure" est utilisé pour accéder au service à l'aide de https car des certificats auto-signés sont utilisé dans cet exemple. N'utilisez pas cet indicateur dans un environnement de production où le certificat public a été signé par une autorité de certification.

Note : Lorsqu'une grappe est supprimée, un équilibreur de charge qui est créé dynamiquement lors de la création d'un service n'est pas supprimé. Avant de supprimer une grappe, supprimez le service, ce qui entraîne la suppression de l'équilibreur de charge. La syntaxe valide de cette commande est la suivante :

kubectl delete svc SERVICE_NAME

Par exemple, pour supprimer le service de l'exemple précédent, entrez :

kubectl delete svc nginx-service

Lorsque Kubernetes Engine provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, vous pouvez spécifier que vous voulez mettre en oeuvre SSL entre l'équilibreur de charge et les serveurs dorsaux (noeuds de travail) du jeu dorsal. Cette configuration est appelée SSL dorsal. Pour mettre en oeuvre le protocole SSL dorsal, vous associez un certificat SSL au jeu dorsal de l'équilibreur de charge.

Notez que vous pouvez mettre en oeuvre le chiffrement SSL point à point complet entre les clients et les pods d'application s'exécutant sur les noeuds de travail. Pour ce faire, associez un certificat SSL au jeu dorsal de l'équilibreur de charge (comme décrit dans cette section) et créez également un équilibreur de charge avec une terminaison SSL (voir Fin du protocole SSL/TLS au niveau de l'équilibreur de charge).

Les suites de chiffrement déterminent la sécurité, la compatibilité et la vitesse du trafic HTTPS (pour plus d'informations, voir Suites de chiffrement pour les équilibreurs de charge). Pour spécifier la suite de chiffrement à utiliser avec le jeu dorsal de l'équilibreur de charge, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

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

où :

• "CipherSuiteName":"<cipher-suite-name>" est le nom d'une suite de chiffrement prédéfinie préconfigurée par Oracle Cloud Infrastructure (voir Suites de chiffrement prédéfinies de l'équilibreur de charge) ou une suite de chiffrement que vous avez créée vous-même. Par exemple, "CipherSuiteName":"oci-default-http2-tls-12-13-ssl-cipher-suite-v1"
• "Protocols":["<tls-version>"] spécifie une ou plusieurs versions TLS, dans une liste délimitée par des virgules. Par exemple, "Protocols":["TLSv1.2", "TLSv1.3"]

Par exemple :

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"]}'

Si vous n'incluez pas l'annotation oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config, mais que vous incluez l'annotation service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret, la suite de chiffrement oci-wider-compatible-ssl-cipher-suite-v1 est utilisée.

Pour spécifier le certificat à associer au jeu dorsal, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret: <value>

où <value> est le nom d'une clé secrète Kubernetes que vous avez créée pour contenir un certificat signé et la clé privée du certificat. Notez que vous devez créer la clé secrète Kubernetes avant de créer le service, car celui-ci la référence dans sa définition.

L'exemple suivant crée et utilise un certificat auto-signé, qui est généralement acceptable pour la communication interne entre l'équilibreur de charge et le jeu dorsal. Toutefois, si vous préférez, vous pouvez utiliser un certificat public qui a été signé par une autorité de certification.

Par exemple :

1. Générez une clé privée en entrant :

   openssl genrsa -out ca.key 2048

2. Générez un certificat en entrant :

   openssl req -x509 -new -nodes -key ca.key -subj "/CN=nginxsvc/O=nginxsvc" -days 10000 -out ca.crt

3. Stockez le certificat et la clé en tant que clé secrète dans Kubernetes en entrant :

   kubectl create secret generic ca-ser-secret --from-file=tls.crt=tls.crt --from-file=tls.key=tls.key --from-file=ca.crt=ca.crt
4. Définissez un déploiement Nginx et exposez-le au moyen d'un équilibreur de charge qui dessert http sur le port 80 et https sur le port 443.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
---
apiVersion: v1
metadata:
  name: nginx-service
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    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"]}'
    service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret: ca-ser-secret
    service.beta.kubernetes.io/oci-load-balancer-ssl-ports: "443" 
spec:
  selector:
    app: nginx
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 80
  - name: https
    port: 443
    targetPort: 443

La communication entre l'équilibreur de charge et les noeuds de travail du jeu dorsal est chiffrée à l'aide de la clé et du certificat stockés dans la clé secrète Kubernetes ca-ser-secret que vous avez créée précédemment.

La forme d'un équilibreur de charge Oracle Cloud Infrastructure indique sa bande passante totale maximale (trafic entrant et sortant). Par défaut, les équilibreurs de charge sont créés avec une forme de 100 Mbits/s. D'autres formes sont disponibles, notamment 400 Mbits/s et 8 000 Mbits/s.

Pour spécifier une autre forme pour un équilibreur de charge, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

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

où value représente la bande passante de la forme (par exemple, 100 Mbits/s, 400 Mbits/s, 8 000 Mbits/s).

Par exemple :

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

Un quota d'équilibreurs de charge suffisant doit être disponible dans la région pour la forme que vous spécifiez. Entrez la commande kubectl suivante pour vérifier que la création de l'équilibreur de charge n'a pas échoué en raison d'un quota insuffisant :

kubectl describe service <service-name>

Notez qu'Oracle recommande de mettre en oeuvre des services Kubernetes de type LoadBalancer en tant qu'équilibreurs de charge flexibles et rentables plutôt qu'en tant qu'équilibreurs de charge à forme fixe (dynamiques) (voir Spécification de formes flexibles d'équilibreur de charge).

La forme d'un équilibreur de charge Oracle Cloud Infrastructure indique sa bande passante totale maximale (trafic entrant et sortant). Comme décrit dans Spécification d'autres formes d'équilibreur de charge, vous pouvez spécifier différentes formes d'équilibreur de charge.

En outre, vous pouvez également spécifier une forme flexible pour un équilibreur de charge d'Oracle Cloud Infrastructure, en définissant une bande passante minimale et maximale pour l'équilibreur de charge.

Pour spécifier une forme flexible pour un équilibreur de charge, ajoutez les annotations suivantes dans la section de métadonnées du fichier manifeste :

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>"

où :

• "<min-value>" est la bande passante minimale pour l'équilibreur de charge, dans Mbps (par exemple, "10")
• "<max-value>" est la bande passante maximale pour l'équilibreur de charge, dans Mbps (par exemple, "100")

Notez que vous n'indiquez pas d'unité de mesure lorsque vous spécifiez des valeurs de bande passante pour les formes d'équilibreur de charge flexibles (contrairement aux formes prédéfinies). Par exemple, spécifiez la bande passante minimale sous la forme 10, et non 10 Mbits/s.

Par exemple :

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

Lors du provisionnement d'un équilibreur de charge Oracle Cloud Infrastructure pour un service Kubernetes de type LoadBalancer, vous pouvez spécifier le délai d'inactivité maximal (en secondes) autorisé entre deux opérations d'envoi ou de réception successives entre le client et les serveurs dorsaux.

Pour spécifier explicitement un délai d'inactivité maximal, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

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

où value correspond au nombre de secondes.

Par exemple :

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

Notez que si vous ne spécifiez pas explicitement un délai d'inactivité maximal, une valeur par défaut est utilisée. La valeur par défaut dépend du type de module d'écoute :

• pour les modules d'écoute TCP, le délai d'inactivité maximal par défaut est de 300 secondes
• pour les modules d'écoute HTTP, le délai d'inactivité maximal par défaut est de 60 secondes

Lorsque le moteur Kubernetes provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, vous pouvez spécifier la taille maximale de l'en-tête HTTP acceptée par les modules d'écoute de l'équilibreur de charge. Vous spécifiez la taille maximale de l'en-tête HTTP à l'aide d'une annotation pour spécifier la taille (en Ko) de la mémoire tampon utilisée pour lire l'en-tête. Les valeurs autorisées pour la taille de la mémoire tampon sont 8, 16, 32 et 64. L'annotation sert à définir une règle d'en-tête HTTP pour l'équilibreur de charge. La règle d'en-tête HTTP s'applique à tous les modules d'écoute de l'équilibreur de charge, sur tous les ports.

Pour plus d'informations sur les règles d'en-tête HTTP, voir Règles d'en-tête HTTP.

Pour spécifier la taille maximale de l'en-tête HTTP acceptée par les modules d'écoute de l'équilibreur de charge, ajoutez l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets dans la section de métadonnées du fichier manifeste. Notez que vous spécifiez la valeur de l'annotation au format JSON, comme suit :

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

où :

• <rule-set-name> est le nom de votre choix pour le jeu de règles (entre 1 et 32 caractères de longueur). Par exemple, header-size.
• <value> est la taille maximale de l'en-tête HTTP dans Ko et est l'une des valeurs suivantes : 8, 16, 32 ou 64.

Par exemple :

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

Pour modifier ultérieurement la taille maximale de l'en-tête HTTP, mettez à jour l'annotation et appliquez de nouveau le manifeste.

Lorsque vous appliquez un manifeste contenant l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets, notez que le moteur Kubernetes prend en charge la gestion de tous les jeux de règles de l'équilibreur de charge. Le moteur Kubernetes ajoute non seulement le jeu de règles d'en-tête HTTP spécifié par l'annotation, mais supprime également tous les autres jeux de règles actuellement associés à l'équilibreur de charge. Notez les points suivants :

• Si vous voulez plus tard supprimer le jeu de règles d'en-tête HTTP de l'équilibreur de charge, spécifiez un objet JSON vide comme valeur de l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets comme suit :

  oci.oraclecloud.com/oci-load-balancer-rule-sets: "{}"

  Lorsque vous spécifiez un objet JSON vide comme valeur de l'annotation, le moteur Kubernetes supprime tous les jeux de règles associés à l'équilibreur de charge et abandonne la gestion des jeux de règles de l'équilibreur de charge.

• Si vous supprimez simplement l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets du manifeste et appliquez-le, le moteur Kubernetes abandonne la gestion des jeux de règles de l'équilibreur de charge. Notez que si vous supprimez l'annotation, le moteur Kubernetes ne supprime aucun des jeux de règles associés à l'équilibreur de charge.

Si vous apportez des modifications directes aux jeux de règles de l'équilibreur de charge (ce qui n'est pas recommandé) plutôt que d'utiliser l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets, notez le point suivant. Si vous appliquez ultérieurement un manifeste contenant l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets, le moteur Kubernetes ajoute le jeu de règles d'en-tête HTTP spécifié par l'annotation et supprime tous les autres jeux de règles associés à l'équilibreur de charge. Par conséquent, si vous voulez conserver les modifications directes apportées aux jeux de règles de l'équilibreur de charge, n'incluez pas l'annotation oci.oraclecloud.com/oci-load-balancer-rule-sets dans le manifeste.

Lorsque Kubernetes Engine provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, vous pouvez définir le type de trafic accepté par le module d'écoute en spécifiant le protocole sur lequel le module d'écoute accepte les demandes de connexion.

Notez que si vous ne spécifiez pas explicitement un protocole, "TCP" est utilisé par défaut.

Pour spécifier explicitement le protocole du module d'écoute de l'équilibreur de charge lorsque Kubernetes Engine provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

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

où <value> est le protocole qui définit le type de trafic accepté par le module d'écoute. Par exemple, "HTTP". Les protocoles valides incluent "HTTP", "TCP" et "GRPC".

Par exemple :

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

Notez que si vous spécifiez GRPC comme protocole, vous devez configurer les deux éléments suivants :

• SSL frontal, à l'aide des annotations service.beta.kubernetes.io/oci-load-balancer-ssl-ports, oci.oraclecloud.com/oci-load-balancer-ssl-listener-config et service.beta.kubernetes.io/oci-load-balancer-tls-secret. Pour plus d'informations, voir Arrêt du protocole SSL/TLS au niveau de l'équilibreur de charge.
• SSL dorsal, à l'aide des annotations oci.oraclecloud.com/oci-load-balancer-backendset-ssl-config et service.beta.kubernetes.io/oci-load-balancer-tls-backendset-secret. Pour plus d'informations, voir Mise en oeuvre de SSL/TLS entre l'équilibreur de charge et les noeuds de travail.

Par exemple :

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

Vous pouvez utiliser la fonction de gestion des listes de sécurité pour configurer la façon dont les règles de liste de sécurité sont gérées pour un équilibreur de charge Oracle Cloud Infrastructure que Kubernetes Engine provisionne pour un service Kubernetes de type LoadBalancer. Cette fonctionnalité est utile si vous démarrez avec Kubernetes, ou pour des déploiements de base.

Pour savoir comment la fonction de gestion des listes de sécurité de Kubernetes gère les listes de sécurité lorsque Kubernetes Engine provisionne un équilibreur de charge pour un service Kubernetes de type LoadBalancer, ajoutez l'annotation suivante dans la section de métadonnées du fichier manifeste :

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

où <value> est l'une des valeurs suivantes :

• "None" : (recommandé) La gestion des listes de sécurité n'est pas activée. Vous devez configurer une règle de sécurité autorisant le trafic entrant vers les ports appropriés pour les intervalles de ports de noeuds, le port d'état kube-proxy et les intervalles de ports de vérification de l'état. De plus, vous devez configurer des règles de sécurité pour autoriser le trafic entrant vers les équilibreurs de charge (voir Règles de sécurité pour les équilibreurs de charge et les équilibreurs de charge de réseau).
• "All" : (par défaut) Toutes les règles de liste de sécurité requises pour les services d'équilibreur de charge sont gérées.
• "Frontend" : Seules les règles de liste de sécurité pour le trafic entrant vers l'équilibreur de charge sont gérées. Vous devez configurer une règle de sécurité autorisant le trafic entrant vers les ports appropriés pour les intervalles de ports de noeuds, le port d'état kube-proxy et les intervalles de ports de vérification de l'état.

Oracle recommande de régler explicitement service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode à None.

Dans les grappes avec des noeuds gérés, si vous ne spécifiez pas explicitement un mode de gestion ou si vous spécifiez une valeur non valide, toutes les règles de liste de sécurité sont gérées (équivalent à "All"). Notez que dans ce cas, le moteur Kubernetes crée une règle de sécurité qui autorise le trafic entrant depuis 0.0.0.0/0 (ou depuis les intervalles de ports sources spécifiés dans le fichier manifeste) vers les ports du module d'écoute. Dans les grappes avec des noeuds virtuels, la gestion des listes de sécurité n'est jamais activée et vous devez toujours configurer manuellement des règles de sécurité (équivalent à "None").

Notez que des limites s'appliquent au nombre de règles de trafic entrant et sortant autorisées dans une liste de sécurité (voir Limites de liste de sécurité). Si le nombre de règles de trafic entrant ou sortant dépasse la limite et que <value> est réglé à "All" ou "Frontend", la création ou la mise à jour de l'équilibreur de charge échoue.

Par exemple :

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