Documentación de Oracle Cloud Infrastructure

Aprovisionamiento de equilibradores de carga de OCI para servicios de Kubernetes de tipo LoadBalancer

Descubra cómo aprovisionar un equilibrador de carga de OCI para un servicio de Kubernetes de tipo LoadBalancer mediante Container Engine for Kubernetes (OKE).

Un equilibrador de carga de OCI es un proxy de capa 4 (TCP) y capa 7 (HTTP) de OSI, que soporta funciones como la terminación SSL y las políticas de enrutamiento HTTP avanzadas. Proporciona la máxima flexibilidad, con escalado y reducción de capacidad de respuesta. Puede elegir un ancho de banda mínimo personalizado y un ancho de banda máximo opcional, tanto entre 10 Mbps como entre 8 000 Mbps. El ancho de banda mínimo siempre está disponible y proporciona preparación instantánea para sus cargas de trabajo.

Para obtener más información sobre los equilibradores de carga de OCI, consulte Visión general de Load Balancer.

El aprovisionamiento de un equilibrador de carga de OCI para un servicio de Kubernetes de tipo LoadBalancer le permite:

  • tráfico de capa 4 y capa 7 (TCP y HTTP) de transporte de equilibrio de carga
  • terminar SSL/TLS en el equilibrador de carga

Tenga en cuenta que cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga de OCI para un servicio de Kubernetes de tipo LoadBalancer, las reglas de seguridad para permitir el tráfico entrante y saliente hacia y desde la subred del equilibrador de carga se crean automáticamente por defecto. Consulte Reglas de seguridad para equilibrador de carga y equilibrador de carga de red.

Utilice las métricas de equilibrador de carga de OCI para supervisar el estado de un equilibrador de carga de OCI aprovisionado para un servicio de Kubernetes de tipo LoadBalancer (consulte Métricas de equilibrador de carga).

Especificación de la anotación para un equilibrador de carga de OCI

Para aprovisionar un equilibrador de carga de Oracle Cloud Infrastructure para un servicio de Kubernetes de tipo LoadBalancer, defina un servicio de tipo LoadBalancer que incluya la siguiente anotación en la sección de metadatos del archivo de manifiesto:
oci.oraclecloud.com/load-balancer-type: "lb"

Tenga en cuenta que lb es el valor por defecto de la anotación oci.oraclecloud.com/load-balancer-type. Si no incluye explícitamente la anotación en la definición del servicio, se utiliza el valor por defecto de la anotación.

Por ejemplo, observe el siguiente archivo de configuración, nginx_lb.yaml. Define un despliegue (kind: Deployment) para la aplicación nginx, seguido de una definición de un servicio de tipo LoadBalancer (type: LoadBalancer) que equilibra el tráfico http en el puerto 80 para la aplicación 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 primera parte del archivo de configuración define un despliegue de Nginx, solicitando que se aloje en 3 pods que ejecuten la imagen nginx:latest y acepten el tráfico a los contenedores en el puerto 80.

La segunda parte del archivo de configuración define el servicio de Nginx, que utiliza el tipo LoadBalancer para equilibrar el tráfico de Nginx en el puerto 80 entre los pods disponibles.

Para crear el despliegue y el servicio definidos en nginx_lb.yaml mientras está conectado al cluster de Kubernetes, introduzca el comando:

kubectl apply -f nginx_lb.yaml

Este comando muestra lo siguiente tras la creación correcta del despliegue y el equilibrador de carga:

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

El equilibrador de carga puede tardar unos minutos en pasar de un estado pendiente a estar totalmente operativo. Para ver el estado actual del cluster, introduzca:

kubectl get all

La salida del comando anterior muestra el estado actual:


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

La salida muestra que el despliegue de my-nginx se está ejecutando en 3 pods (las entradas po/my-nginx), que el equilibrador de carga está en ejecución (svc/my-nginx-svc) y tiene una IP externa (192.0.2.22) que los clientes pueden utilizar para conectarse a la aplicación desplegada en los pods.

Terminación de SSL/TLS en el equilibrador de carga

Cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga para un servicio de Kubernetes de tipo LoadBalancer, puede especificar que desea terminar SSL en el equilibrador de carga. Esta configuración se conoce como SSL de frontend. Para implementar SSL de frontend, defina un listener en un puerto como el 443, y asocie un certificado SSL al listener.

Tenga en cuenta que puede implantar el cifrado SSL punto a punto completo entre clientes y pods de aplicación que se ejecutan en nodos de trabajador. Para ello, cree un equilibrador de carga con terminación SSL (como se describe en esta sección) y, además, asocie un certificado SSL al juego de backends del equilibrador de carga (consulte Implantación de SSL/TLS entre el equilibrador de carga y los nodos de trabajador).

Este ejemplo proporciona un tutorial sobre la configuración y la creación de un equilibrador de carga con soporte SSL.

Tenga en cuenta el siguiente archivo de configuración, nginx-demo-svc-ssl.yaml, que define un despliegue de Nginx y lo expone a través de un equilibrador de carga que sirve http en el puerto 80 y https en el puerto 443. Este ejemplo crea un equilibrador de carga de Oracle Cloud Infrastructure, definiendo un servicio con un tipo de 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"
    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

Las anotaciones del equilibrador de carga tienen una importancia concreta. Los puertos en los que se soporta el tráfico https se definen mediante el valor service.beta.kubernetes.io/oci-load-balancer-ssl-ports. Puede declarar varios puertos SSL mediante una lista separada por comas para el valor de la anotación. Por ejemplo, puede definir el valor de la anotación en "443, 3000" para que soporte SSL en los puertos 443 y 3000.

Se debe crear el secreto TLS requerido ssl-certificate-secret en Kubernetes. En este ejemplo, se crea y utiliza un certificado autofirmado. Sin embargo, en un entorno de producción, el escenario más común es utilizar un certificado público que haya sido firmado por una autoridad de certificación.

El siguiente comando crea un certificado autofirmado, tls.crt, con su clave correspondiente, tls.key:

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

Ahora que ha creado el certificado, debe almacenarlo con su clave como un secreto en Kubernetes. El nombre del secreto debe coincidir con el nombre de la anotación service.beta.kubernetes.io/oci-load-balancer-tls-secret de la definición del equilibrador de carga. Utilice el siguiente comando para crear un secreto TLS en Kubernetes, cuyos valores de clave y certificado están definidos por --key y --cert, respectivamente.

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

Debe crear el secreto de Kubernetes antes de crear el servicio, ya que el servicio hace referencia al secreto en su definición. Cree el servicio con el siguiente comando:

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

Observe el servicio y espere a que se asigne una dirección IP pública (EXTERNAL-IP) al servicio de Nginx (nginx-service) introduciendo:

kubectl get svc --watch

La salida del comando anterior muestra la IP del equilibrador de carga que se va a utilizar para conectarse al servicio.


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

El equilibrador de carga se está ejecutando, lo que significa que ahora se puede acceder al servicio de la siguiente manera:

  • mediante http, introduciendo:
    curl http://198.51.100.1
  • mediante https, introduciendo:
    curl --insecure https://198.51.100.1

    El indicador "--insecure" se utiliza para acceder al servicio mediante https debido al uso de certificados autofirmados en este ejemplo. No utilice este indicador en un entorno de producción donde la autoridad de certificación firmó el certificado público.

Nota: Cuando se suprime un cluster, no se elimina un equilibrador de carga creado de forma dinámica cuando se crea un servicio. Antes de suprimir un cluster, suprima el servicio que, a su vez, provocará la eliminación del equilibrador de carga. La sintaxis para este comando es:

kubectl delete svc SERVICE_NAME

Por ejemplo, para suprimir el servicio del ejemplo anterior, introduzca:

kubectl delete svc nginx-service

Actualización de los certificados TLS de equilibradores de carga existentes

Para actualizar el certificado TLS de un equilibrador de carga existente:
  1. Obtenga un nuevo certificado TLS. En un entorno de producción, el escenario más común es utilizar un certificado público que haya sido firmado por una autoridad de certificación.

  2. Cree un nuevo secreto de Kubernetes. Por ejemplo, introduzca:

    kubectl create secret tls new-ssl-certificate-secret --key new-tls.key --cert new-tls.crt
  3. Modifique la definición de servicio para hacer referencia al nuevo secreto de Kubernetes cambiando la anotación service.beta.kubernetes.io/oci-load-balancer-tls-secret en la configuración de servicio. Por ejemplo:
    
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-ssl-ports: "443"
    service.beta.kubernetes.io/oci-load-balancer-tls-secret: new-ssl-certificate-secret
spec:
  selector:
    app: nginx
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 80
  - name: https
    port: 443
    targetPort: 80
  4. Actualice el servicio. Por ejemplo, introduzca:
    kubectl apply -f new-nginx-demo-svc-ssl.yaml

Implementación de SSL/TLS entre el equilibrador de carga y los nodos de trabajador

Cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga para un servicio de Kubernetes de tipo LoadBalancer, puede especificar que desea implantar SSL entre el equilibrador de carga y los servidores backend (nodos de trabajador) en el juego de backends. Esta configuración se conoce como SSL de backend. Para implantar SSL de backend, debe asociar un certificado SSL al juego de backends del equilibrador de carga.

Tenga en cuenta que puede implantar el cifrado SSL punto a punto completo entre clientes y pods de aplicación que se ejecutan en nodos de trabajador. Para ello, asocie un certificado SSL al juego de backends del equilibrador de carga (como se describe en esta sección) y, además, cree un equilibrador de carga con la terminación SSL (consulte Terminación de SSL/TLS en el equilibrador de carga).

Para especificar el certificado que se va a asociar al juego de backends, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde <value> es el nombre de un secreto de Kubernetes que ha creado para contener un certificado firmado y la clave privada del certificado. Tenga en cuenta que debe crear el secreto de Kubernetes antes de crear el servicio, ya que el servicio hace referencia al secreto en su definición.

En el siguiente ejemplo se crea y utiliza un certificado autofirmado, que suele ser aceptable para la comunicación interna entre el equilibrador de carga y el juego de backends. Sin embargo, si lo prefiere, puede utilizar un certificado público firmado por una autoridad de certificación.

Por ejemplo:

  1. Para generar una clave privada, introduzca:

    openssl genrsa -out ca.key 2048

  2. Genere un certificado introduciendo:

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

  3. Almacene el certificado y la clave como secreto en Kubernetes introduciendo:

    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. Definir un despliegue de Nginx y exponerlo mediante un equilibrador de carga que sirva http en el puerto 80 y https en el puerto 443. Este ejemplo crea un equilibrador de carga de Oracle Cloud Infrastructure, definiendo un servicio con un tipo de 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
---
apiVersion: v1
metadata:
  name: nginx-service
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    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 comunicación entre el equilibrador de carga y los nodos de trabajador del juego de backends se cifra mediante la clave y el certificado almacenados en el secreto de Kubernetes ca-ser-secret que ha creado anteriormente.

Especificación de unidades de computación de equilibrador de carga alternativas

La unidad de computación de un equilibrador de carga de Oracle Cloud Infrastructure especifica su ancho de banda total máximo (es decir, entrada más salida). Por defecto, los equilibradores de carga se crean con una unidad de computación de 100 Mbps. Hay otras unidades disponibles, incluidos 400 Mbps y 8000 Mbps.

Para especificar una unidad alternativa para un equilibrador de carga, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde value es el ancho de banda de la unidad de computación (por ejemplo, 100 Mbps, 400 Mbps, 8000 Mbps).

Por ejemplo:


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

Debe haber suficiente cuota de equilibrador de carga disponible en la región para la unidad de computación que especifique. Introduzca el siguiente comando de kubectl para confirmar que la creación del equilibrador de carga no ha fallado debido a la falta de cuota:

kubectl describe service <service-name>

Tenga en cuenta que Oracle recomienda implantar servicios de Kubernetes de tipo LoadBalancer como equilibradores de carga flexibles rentables en lugar de como equilibradores de carga de unidad fija (dinámicos) (consulte Especificación de unidades de equilibrador de carga flexibles).

Especificación de unidades de equilibrador de carga flexibles

La unidad de computación de un equilibrador de carga de Oracle Cloud Infrastructure especifica su ancho de banda total máximo (es decir, entrada más salida). Como se describe en Especificación de unidades de equilibrador de carga alternativas, puede especificar diferentes unidades de equilibrador de carga.

Además, también puede especificar una unidad flexible para un equilibrador de carga de Oracle Cloud Infrastructure definiendo un ancho de banda mínimo y máximo para el equilibrador de carga.

Para especificar una unidad flexible para un equilibrador de carga, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde:

  • "<min-value>" es el ancho de banda mínimo para el equilibrador de carga, en Mbps (por ejemplo, "10"
  • "<max-value>" es el ancho de banda máximo para el equilibrador de carga, en Mbps (por ejemplo, "100")

Tenga en cuenta que no debe incluir una unidad de medida al especificar valores de ancho de banda para unidades de equilibrador de carga flexibles (a diferencia de para las unidades predefinidas). Por ejemplo, especifique el ancho de banda mínimo como 10 en lugar de 10Mbps.

Por ejemplo:


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

Especificación de timeout de conexión de equilibrador de carga

Al aprovisionar un equilibrador de carga de Oracle Cloud Infrastructure para un servicio de Kubernetes de tipo LoadBalancer, puede especificar el tiempo máximo de inactividad (en segundos) permitido entre dos operaciones de recepción sucesivas o dos operaciones de envío sucesivas entre el cliente y los servidores backend.

Para especificar explícitamente un tiempo de inactividad máximo, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde value es el número de segundos.

Por ejemplo:


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

Tenga en cuenta que si no especifica explícitamente un tiempo de inactividad máximo, se utilizará un valor por defecto. El valor por defecto depende del tipo de listener:

  • para listeners TCP, el tiempo máximo de inactividad por defecto es 300 segundos
  • para listeners HTTP, el tiempo máximo de inactividad por defecto es 60 segundos

Especificación de Protocolos de Listener

Cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga para un servicio de Kubernetes de tipo LoadBalancer, puede definir el tipo de tráfico aceptado por el listener especificando el protocolo en el que el listener acepta las solicitudes de conexión.

Tenga en cuenta que si no especifica explícitamente un protocolo, "TCP" se utilizará como valor por defecto.

Para especificar explícitamente el protocolo de listener de equilibrador de carga cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga para un servicio de Kubernetes de tipo LoadBalancer, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde <value> es el protocolo que define el tipo de tráfico aceptado por el listener. Por ejemplo, "HTTP". Los protocolos válidos incluyen "HTTP" y "TCP".

Por ejemplo:


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

Especificación de opciones de gestión de lista de seguridad al aprovisionar un equilibrador de carga de OCI

Nota

Puede encontrar escalabilidad y otros problemas si utiliza la función de gestión de lista de seguridad de Kubernetes en despliegues complejos y con herramientas como Terraform. Por estos motivos, Oracle no recomienda utilizar la función de gestión de lista de seguridad de Kubernetes en entornos de producción.

Tenga en cuenta también que la capacidad de utilizar listas de seguridad para gestionar reglas de seguridad quedará en desuso en futuras versiones. Por este motivo, Oracle recomienda el uso de grupos de seguridad de red (NSG) y la anotación oci.oraclecloud.com/security-rule-management-mode (consulte Especificación de opciones de gestión de reglas de seguridad para equilibradores de carga y equilibradores de carga de red).

Puede utilizar la función de gestión de listas de seguridad para configurar cómo se gestionan las reglas de listas de seguridad para un equilibrador de carga de Oracle Cloud Infrastructure que Container Engine for Kubernetes aprovisiona para un servicio de Kubernetes de tipo LoadBalancer. Esta función es útil si es no está familiarizado con Kubernetes o para despliegues básicos.

Para especificar cómo la función de gestión de lista de seguridad de Kubernetes gestiona las listas de seguridad cuando Container Engine for Kubernetes aprovisiona un equilibrador de carga para un servicio de Kubernetes de tipo LoadBalancer, agregue la siguiente anotación en la sección de metadatos del archivo de manifiesto:

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

donde <value> es uno de:

  • "None": (recomendado) no está activada la gestión de listas de seguridad. Debe configurar una regla de seguridad que permita tráfico entrante a los puertos adecuados para rangos de puertos de nodo, el puerto de estado de kube-proxy y los rangos de puertos de comprobación del sistema. Además, debe configurar reglas de seguridad para permitir tráfico entrante a equilibradores de carga (consulte Reglas de seguridad para equilibradores de carga y equilibradores de carga de red).
  • "All": (por defecto) todas las reglas de la lista de seguridad necesarias para los servicios de equilibrador de carga están gestionadas.
  • "Frontend": solo se gestionan reglas de lista de seguridad para entrada a servicios de equilibrador de carga. Debe configurar una regla de seguridad que permita tráfico entrante a los puertos adecuados para rangos de puertos de nodo, el puerto de estado de kube-proxy y los rangos de puertos de comprobación del sistema.

Oracle recomienda definir explícitamente service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode en None.

En los clusters con nodos gestionados, si no especifica explícitamente un modo de gestión o especifica un valor no válido, se gestionan todas las reglas de la lista de seguridad (equivalente a "All"). Tenga en cuenta que, en este caso, Container Engine for Kubernetes crea una regla de seguridad que permite el tráfico entrante desde 0.0.0.0/0 (o desde los rangos de puertos de origen especificados en el archivo de manifiesto) hasta los puertos del listener. En los clusters con nodos virtuales, la gestión de listas de seguridad nunca se activa y siempre tiene que configurar manualmente las reglas de seguridad (equivalente a "None").

Tenga en cuenta que hay límites en el número de reglas de entrada y salida permitidas en una lista de seguridad (consulte Límites de lista de seguridad). Si el número de reglas de entrada o salida supera el límite y <value> está definido en "All" o "Frontend", la creación o actualización del equilibrador de carga falla.

Por ejemplo:


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