Todos os produtos
Search
Central de documentação

Container Service for Kubernetes:Expose Services Across Multiple Regions Using ELB

Última atualização: Jul 05, 2026

O Edge Load Balancer (ELB) permite expor aplicações implantadas em vários node pools do ENS por meio de um único Kubernetes LoadBalancer Service. Cada node pool recebe sua própria instância de ELB na respectiva região, e o edge-controller-manager (ECM) vincula o ciclo de vida dessas instâncias aos resources PoolService criados automaticamente.

Este tópico demonstra como implantar uma aplicação em node pools do ENS em duas regiões e expô-la usando um LoadBalancer Service com suporte a ELB.

Existem duas opções para provisionar instâncias de ELB. Se você não possui instâncias de ELB existentes, use a Opção 1 (recomendada) para permitir que o ECM as crie automaticamente. Caso precise anexar instâncias de ELB pré-provisionadas — por exemplo, para compartilhar uma única instância entre vários Services — utilize a Opção 2 .

Como funciona

Ao criar um LoadBalancer Service com loadBalancerClass: alibabacloud.com/elb, o ECM busca node pools que correspondam ao seletor de node pool do Service. Para cada node pool correspondente, ele cria um PoolService e provisiona uma instância de ELB na região desse node pool. Em seguida, o ECM vincula o ciclo de vida da instância de ELB e seu endereço IP elástico (EIP) associado ao PoolService.

O resultado é um único Service com múltiplos IPs externos, um por região.

image

Pré-requisitos

Antes de começar, certifique-se de ter:

  • Um cluster ACK Edge com a versão 2.1.0 ou superior do ECM

  • Node pools do ENS já criados nas regiões de destino (este exemplo usa China (Hefei) e China (Chengdu))

  • Redes de borda criadas para suas instâncias ENS

Para instâncias ENS sem interfaces de rede elástica (ENIs), use instâncias de ELB para expô-las e atribua EIPs ou configure NAT para acesso à Internet. Já para instâncias ENS com ENIs, é necessário adicionar regras de roteamento à rede do host — consulte Precauções para obter os comandos necessários.

Precauções

  • O ECM configura instâncias de ELB apenas para Services com type: LoadBalancer. É necessária a versão 2.1.0 ou superior do ECM.

  • As instâncias de ELB e os EIPs gerenciados pelo ECM recebem o nome k8s/${Service_Name}/${Service_Namespace}/${NodePool_Id}/${Cluster_Id}. Evite nomes duplicados, pois resources com o mesmo nome podem ser excluídos acidentalmente.

  • Para compartilhar uma única instância de ELB entre vários Services, utilize um EIP e uma instância de ELB autogerenciados e defina externalTrafficPolicy: Cluster.

  • Para instâncias ENS com ENIs atribuídas, adicione regras de roteamento à rede do host de cada nó:

    # 10.0.0.3 is the internal network interface; 10.0.0.1 is the internal gateway.
    ip rule add from 10.0.0.3 lookup 4
    ip route add default via 10.0.0.1 table 4

Etapa 1: Implantar uma aplicação

Implante a aplicação cube como um DaemonSet para que ela seja executada em todos os nós dos node pools do ENS.

  1. Crie um arquivo chamado cube.yaml com o seguinte conteúdo:

    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: cube
      labels:
        app: cube
    spec:
      selector:
        matchLabels:
          app: cube
      template:
        metadata:
          labels:
            app: cube
        spec:
          containers:
          - name: cube
            image: registry.cn-hangzhou.aliyuncs.com/acr-toolkit/ack-cube:1.0
            ports:
            - containerPort: 80
  2. Aplique o DaemonSet:

    kubectl apply -f cube.yaml
  3. Verifique se todos os pods estão em execução:

    kubectl get ds cube

    Saída esperada:

    NAME   DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
    cube   4         4         4       4            4           <none>          3d1h

Etapa 2: Adicionar anotações aos node pools

Adicione as anotações de rede necessárias e um rótulo seletor de Service a cada node pool do ENS. Execute estes comandos para todos os node pools — neste exemplo, os node pools em China (Hefei) e China (Chengdu).

  1. Obtenha os nomes dos node pools:

    kubectl get nodepool
  2. Adicione o ID da rede ENS:

    kubectl annotate nodepool np-xxx alibabacloud.com/ens-network-id=n-xxx
  3. Adicione o ID da região ENS:

    kubectl annotate nodepool np-xxx alibabacloud.com/ens-region-id=cn-xxx-xxx
  4. Adicione o ID do vSwitch:

    kubectl annotate nodepool np-xxx alibabacloud.com/ens-vswitch-id=vsw-xxx,vsw-xxx
  5. Adicione o rótulo seletor de Service usado para vincular este node pool ao Service:

    kubectl label nodepool np-xxx k8s-svc=cube

Etapa 3: Expor a aplicação com um ELB Service

Importante

Defina type: LoadBalancer e loadBalancerClass: alibabacloud.com/elb no Service. Sem esses campos, o ECM não provisiona instâncias de ELB.

Escolha uma das abordagens abaixo, dependendo se você deseja que o ECM crie instâncias de ELB automaticamente ou se prefere usar instâncias existentes.

Opção 1: Permitir que o ECM crie instâncias de ELB automaticamente

Importante

Excluir o Service, excluir um node pool ou alterar o seletor de node pool remove as instâncias de ELB e os EIPs correspondentes. Se você atualizar os rótulos do node pool de modo que não correspondam mais ao seletor, as instâncias de ELB desses node pools também serão excluídas.

  1. Crie um arquivo chamado cube-svc.yaml:

    • openyurt.io/topologyKeys: habilita o roteamento com reconhecimento de topologia para que o tráfego permaneça dentro da região de cada node pool.

    • service.openyurt.io/nodepool-labelselector: seleciona quais node pools receberão instâncias de ELB.

    • externalTrafficPolicy: Local: preserva o IP do cliente e roteia o tráfego apenas para pods no mesmo nó.

    apiVersion: v1
    kind: Service
    metadata:
      name: cube-svc
      labels:
        app: cube
      annotations:
        openyurt.io/topologyKeys: openyurt.io/nodepool           # Route traffic within each node pool.
        service.openyurt.io/nodepool-labelselector: k8s-svc=cube # Select node pools with this label.
    spec:
      selector:
        app: cube
      type: LoadBalancer
      loadBalancerClass: alibabacloud.com/elb
      externalTrafficPolicy: Local
      ports:
      - name: cube
        port: 80
        protocol: TCP
        targetPort: 80

    Campos principais:

  2. Aplique o Service:

    kubectl apply -f cube-svc.yaml
  3. Confirme se o Service está pronto e anote os IPs externos:

    kubectl get svc cube-svc

    Saída esperada:

    NAME       TYPE           CLUSTER-IP        EXTERNAL-IP                    PORT(S)        AGE
    cube-svc   LoadBalancer   192.168.xxx.xxx   39.106.XX.XX,144.121.XX.XX     80:30081/TCP   5m
  4. Acesse a aplicação:

    curl http://<EXTERNAL-IP>:80

    Substitua <EXTERNAL-IP> por um dos IPs da coluna EXTERNAL-IP.

Opção 2: Usar instâncias de ELB existentes

Utilize esta opção quando precisar anexar instâncias de ELB pré-provisionadas, por exemplo, para compartilhar uma instância de ELB entre vários Services.

  1. Crie um arquivo chamado cube-svc.yaml:

    apiVersion: v1
    kind: Service
    metadata:
      name: cube-svc
      labels:
        app: cube
      annotations:
        openyurt.io/topologyKeys: openyurt.io/nodepool             # Route traffic within each node pool.
        service.openyurt.io/nodepool-labelselector: k8s-svc=cube   # Select node pools with this label.
        service.beta.kubernetes.io/alibaba-cloud-loadbalancer-managed-by-user: "true" # Use a self-managed ELB instance.
    spec:
      selector:
        app: cube
      type: LoadBalancer
      loadBalancerClass: alibabacloud.com/elb
      externalTrafficPolicy: Local
      ports:
      - name: cube
        port: 80
        protocol: TCP
        targetPort: 80
  2. Aplique o Service:

    kubectl apply -f cube-svc.yaml
  3. Verifique os PoolServices criados automaticamente — um por node pool:

    kubectl get ps

    Saída esperada:

    NAME                   AGE
    cube-svc-np-heifei     32s
    cube-svc-np-chengdu    32s
  4. Anexe uma instância de ELB existente a cada PoolService:

    • Node pool de China (Hefei): ``bash kubectl annotate ps cube-svc-np-heifei service.beta.kubernetes.io/alibaba-cloud-loadbalancer-id=lb-xxx ``

    • Node pool de China (Chengdu): ``bash kubectl annotate ps cube-svc-np-chengdu service.beta.kubernetes.io/alibaba-cloud-loadbalancer-id=lb-xxx ``

  5. Confirme se o Service está pronto:

    kubectl get svc cube-svc

    Saída esperada:

    NAME       TYPE           CLUSTER-IP        EXTERNAL-IP                    PORT(S)        AGE
    cube-svc   LoadBalancer   192.168.xxx.xxx   39.106.XX.XX,144.121.XX.XX     80:30081/TCP   5m
  6. Acesse a aplicação:

    curl http://<EXTERNAL-IP>:80

    Substitua <EXTERNAL-IP> por um dos IPs da coluna EXTERNAL-IP.

Política de atualização do ELB

A tabela abaixo resume o comportamento dos resources dependendo se a instância de ELB é gerenciada por você ou pelo ECM.

Resource

ELB autogerenciado

ELB gerenciado pelo ECM

Atributos do ELB

Criação: especifique o seletor de node pool e o ID do ELB via service.openyurt.io/nodepool-labelselector e service.beta.kubernetes.io/alibaba-cloud-loadbalancer-managed-by-user. Atualização: não suportada. Exclusão: não automática.

Criação: especifique o seletor de node pool via service.openyurt.io/nodepool-labelselector. Atualização: não suportada. Exclusão: não automática.

Grupos de servidores de backend

Criação: atualizado com base no status do Service e dos pods. Atualização: servidores são adicionados ou removidos dinamicamente no modo Local. Exclusão: não automática — exclua manualmente.

Criação: atualizado com base no status do Service e dos pods. Atualização: servidores são adicionados ou removidos dinamicamente no modo Local. Exclusão: automática.

Listeners

Criação: adicionados com base em spec.ports. Atualização: adicionados, atualizados e excluídos com base nas alterações de porta. Exclusão: não automática — exclua manualmente.

Criação: adicionados com base em spec.ports. Atualização: adicionados, atualizados e excluídos com base nas alterações de porta. Exclusão: automática.

Atributos de EIP

Criação: não automática — gerencie os EIPs manualmente. Atualização: não suportada. Exclusão: não automática.

Criação: automática, na mesma região da instância de ELB. Atualização: a largura de banda pode ser aumentada ou diminuída. Exclusão: automática.

Próximos passos