使用generation tool like Pulumi，您可以生成一个符合您的标准的负载均衡器（至少作为测试的起点）。
下面是一个用Go写的：

package main

import (
    "fmt"

    "github.com/pulumi/pulumi-oci/sdk/v4/go/oci/core"
    "github.com/pulumi/pulumi-oci/sdk/v4/go/oci/loadbalancer"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        // Get the current compartment ID from the OCI configuration
        compartmentID := ctx.GetConfig("oci").Require("compartment")
        // Replace with your OKE cluster's corresponding VCN (Virtual Cloud Network) ID and subnet ID
        vcnID := "your-vcn-id"
        subnetID := "your-subnet-id"

        // Create Load Balancer
        lb, err := loadbalancer.NewLoadBalancer(ctx, "mylb", &loadbalancer.LoadBalancerArgs{
            DisplayName:     pulumi.String("MySQL-InnoDB-Cluster-LB"),
            ShapeName:       pulumi.String("100Mbps"),
            CompartmentId:   pulumi.String(compartmentID),
            IsPrivate:       pulumi.Bool(false),
            LoadBalancerSubnets: pulumi.StringArray{
                pulumi.String(subnetID),
                // Add additional subnet ID(s) if required
            },
        })
        if err != nil {
            return err
        }

        // Create backend sets for ports 6446 and 6447
        backendPortMappings := []struct {
            name string
            port int
        }{
            {name: "mysql1", port: 6446},
            {name: "mysql2", port: 6447},
        }

        for _, portMapping := range backendPortMappings {
            backendSetName := fmt.Sprintf("backend-set-%s", portMapping.name)
            _, err = loadbalancer.NewBackendSet(ctx, backendSetName, &loadbalancer.BackendSetArgs{
                LoadBalancerId: lb.ID(),
                Name:           pulumi.String(backendSetName),
                Policy:         pulumi.String("LEAST_CONNECTIONS"),
                HealthChecker: &loadbalancer.BackendSetHealthCheckerArgs{
                    Protocol: pulumi.String("TCP"),
                    Port:     pulumi.Int(portMapping.port),
                },
            })
            if err != nil {
                return err
            }

            listenerName := fmt.Sprintf("listener-%s", portMapping.name)
            _, err = loadbalancer.NewListener(ctx, listenerName, &loadbalancer.ListenerArgs{
                LoadBalancerId: lb.ID(),
                Name:           pulumi.String(listenerName),
                DefaultBackendSetName: pulumi.String(backendSetName),
                Port:           pulumi.Int(portMapping.port),
                Protocol:       pulumi.String("TCP"),
            })
            if err != nil {
                return err
            }
        }

        // Export the Load Balancer IP address
        publicIpAddress := lb.IpAddresses.Index(0).IpAddress
        ctx.Export("lbPublicIP", publicIpAddress)

        return nil
    })
}

它创建了一个OCI负载均衡器、每个端口（6446和6447）的后端集以及相应的侦听器。
（将vcnID和subnetID替换为OKE群集的适当值）。
要运行此Pulumi Go程序：

• 确保您已安装Pulumi CLI和Go。
• 为Pulumi设置OCI配置（API密钥和区域）。
• 使用pulumi new go创建一个新的Pulumi项目。
• 用提供的代码替换main.go的内容。
• 运行pulumi up部署资源。

这不是唯一的方法，你可以使用YAML配置文件来代替：

---
description: Pulumi YAML to create OCI Load Balancer for MySQL InnoDB Cluster
imports:
  - pulumi
  - pulumi_oci as oci

config:
  oci:compartment: {}
  vcnID: {}
  subnetID: {}

resources:
  
  - name: mylb
    type: oci:loadbalancer/loadBalancer:LoadBalancer
    args:
      displayName: MySQL-InnoDB-Cluster-LB
      shapeName: 100Mbps
      compartmentId: !config:oci:compartment
      isPrivate: false
      loadBalancerSubnets:
        - !config:subnetID
        
  - name: backend-set-mysql1
    type: oci:loadbalancer/backendSet:BackendSet
    args:
      loadBalancerId: !ref:mylb
      name: backend-set-mysql1
      policy: LEAST_CONNECTIONS
      healthChecker:
        protocol: TCP
        port: 6446
        
  - name: listener-mysql1
    type: oci:loadbalancer/listener:Listener
    args:
      loadBalancerId: !ref:mylb
      name: listener-mysql1
      defaultBackendSetName: !ref:backend-set-mysql1
      port: 6446
      protocol: TCP
        
  - name: backend-set-mysql2
    type: oci:loadbalancer/backendSet:BackendSet
    args:
      loadBalancerId: !ref:mylb
      name: backend-set-mysql2
      policy: LEAST_CONNECTIONS
      healthChecker:
        protocol: TCP
        port: 6447
        
  - name: listener-mysql2
    type: oci:loadbalancer/listener:Listener
    args:
      loadBalancerId: !ref:mylb
      name: listener-mysql2
      defaultBackendSetName: !ref:backend-set-mysql2
      port: 6447
      protocol: TCP

outputs:
  lbPublicIP:
    value: !index:.resources[!ref:mylb].outputs.ipAddresses 0

在这种情况下：

• 为Pulumi设置OCI配置（API密钥和区域）。
• 使用pulumi new pulumi-yaml创建一个新的Pulumi项目。
• 用提供的YAML代码替换Pulumi.yaml的内容。
• 使用pulumi config set设置所需配置：

pulumi config set oci:compartment <compartment-id>
pulumi config set vcnID <your-vcn-id>
pulumi config set subnetID <your-subnet-id>

• 运行pulumi up部署资源。

部署完成后，程序将输出负载均衡器的公共IP地址，您可以使用该地址在Internet上访问MySQL InnoDB集群。
这两种实现都将遵循Oracle在其文章“Comparing OCI Load Balancers: Quickly and Easily”中描述的内容：
参考Oracle Cloud Infrastructure（OCI）文档“https://docs.oracle.com/en-us/iaas/Content/Balance/Concepts/balanceoverview.htm”
Oracle Cloud Load Balancer服务提供第7层负载平衡器，它以更复杂的方式路由网络流量，适用于HTTP等基于TCP的流量。

• 首先，负载平衡器终止网络流量并读取其中的消息。
• 然后，它根据消息或消息头的内容做出决定。

此外，它还提供了一个可弹性扩展的区域VIP地址，可以使用灵活的形状向上或向下扩展，最高可达8000 Mbps。
第7层负载均衡在OSI模型的高级应用层运行，处理每条消息的实际内容。
HTTP是Internet上用于网站流量的主要第7层协议。
第7层负载平衡器终止网络流量并读取其中的消息。它可以根据消息的内容（例如URL或cookie）做出负载平衡决策。然后，通过keepalives和处理请求，创建一个到所选后端服务器的新TCP连接或重用现有连接。