Todos os produtos
Search

Este produto

    Server Load Balancer:Use ALB Ingress on a self-managed K8s cluster

    Central de documentação

    Server Load Balancer:Use ALB Ingress on a self-managed K8s cluster

    Última atualização: Jul 07, 2026

    Este tópico descreve como usar um ALB Ingress em um cluster Kubernetes autogerenciado executado no Alibaba Cloud para gerenciar o tráfego com o Application Load Balancer (ALB).

    Cenário de exemplo

    Este tópico usa o cenário ilustrado na figura a seguir, em que um cluster Kubernetes autogerenciado no Alibaba Cloud utiliza um ALB Ingress para rotear requisições.

    Implante o alb-ingress-controller e crie recursos de Ingress e Service no cluster Kubernetes autogerenciado. O alb-ingress-controller sincroniza as configurações do Ingress com uma instância ALB como regras de encaminhamento. Ele também monitora o API Server do cluster para detectar alterações nos Ingresses e sincroniza essas atualizações com a instância ALB. A instância ALB roteia dinamicamente o tráfego para os pods correspondentes no cluster. Para mais informações, consulte Gerenciamento de ALB Ingress.

    ALB Ingress场景示例

    Observações de uso

    • Se você usar um plug-in de rede overlay, como o Flannel, o serviço de backend do ALB Ingress deverá ser do tipo NodePort ou LoadBalancer.

    • Os nomes dos recursos AlbConfig, Namespace, Ingress e Service não podem começar com aliyun.

    Pré-requisitos

    Procedimento

    配置步骤

    As etapas a seguir envolvem a modificação de vários arquivos. A tabela abaixo descreve a finalidade de cada um.

    Etapa

    Nome do arquivo

    Finalidade

    Etapa 1: Implantar o alb-ingress-controller

    load-balancer-controller.yaml

    Modificado a partir de um modelo

    Implantar o alb-ingress-controller

    Etapa 2: Criar recursos AlbConfig e IngressClass

    alb.yaml

    Criado e modificado

    Criar recursos AlbConfig e IngressClass, o que gera automaticamente uma instância ALB

    Etapa 3: Implantar uma aplicação de teste

    test-service.yaml

    Criado e modificado

    Implantar um serviço de teste

    Etapa 4: Criar um Ingress

    test-ingress.yaml

    Criado e modificado

    Criar um Ingress

    Etapa 1: Implantar o alb-ingress-controller

    Nota

    O pull da imagem de implantação pode falhar devido a problemas de rede da operadora. Para evitar isso, use uma imagem privada. Compile-a e envie-a seguindo as instruções em Implantar o controller a partir do código-fonte.

    Neste tópico, o alb-ingress-controller inicia no modo InCluster. Após configurar as permissões para observar recursos de Service, Endpoint e Node, use o arquivo load-balancer-controller.yaml para implantar o alb-ingress-controller. Os recursos ServiceAccount, Deployment e ConfigMap necessários já vêm pré-configurados. Modifique-os apenas para adequá-los ao seu ambiente.

    1. Modifique o arquivo load-balancer-controller.yaml para alterar a imagem do Deployment para um endereço de imagem acessível.

      O arquivo load-balancer-controller.yaml serve para implantar o alb-ingress-controller.

      Antes da modificação:

      image: ${path/to/your/image/registry}

      Após a modificação:

      image: alibabacloudslb/alibaba-load-balancer-controller:v1.2.0  # An x86-compiled image.

    2. Edite o arquivo load-balancer-controller.yaml para configurar o AccessKey ID e o AccessKey Secret no ConfigMap.

      Nota

      Faça login no RAM console com a conta Alibaba Cloud que será usada para criar a instância ALB. Em seguida, visualize o AccessKey ID e o AccessKey Secret na página AccessKey.

      apiVersion: v1
kind: ConfigMap
metadata:
  name: load-balancer-config
  namespace: kube-system
data:
  cloud-config.conf: |-
       {
           "Global": {
               "AccessKeyID": "<YOUR_ACCESS_KEY_ID>", # Base64 encoding is required.
               "AccessKeySecret": "<YOUR_ACCESS_KEY_SECRET>" # Base64 encoding is required.
           }
       }

    3. Conecte-se ao cluster usando kubectl e execute o comando a seguir para aplicar o arquivo load-balancer-controller.yaml modificado.

      kubectl apply -f load-balancer-controller.yaml

      Saída esperada:

      clusterrole.rbac.authorization.k8s.io/system:load-balancer-controller created
serviceaccount/load-balancer-controller created
clusterrolebinding.rbac.authorization.k8s.io/system:load-controller-manager created
configmap/load-balancer-config created
deployment.apps/load-balancer-controller created

    4. Execute o comando abaixo para verificar a implantação do alb-ingress-controller.

      kubectl -n kube-system get all | grep load-balancer

      A saída a seguir mostra que o pod está no estado Running, indicando uma implantação bem-sucedida.

      [root@iZ2ze9xxx uoZ test]# kubectl -n kube-system get all | grep load-balancer
pod/load-balancer-controller-67985dd48d-qtgl8       1/1     Running   0          61d
deployment.apps/load-balancer-controller   1/1   1            1           62d
replicaset.apps/load-balancer-controller-67985dd48d   1         1         1       62d

    Etapa 2: Criar recursos AlbConfig e IngressClass

    Após criar os recursos AlbConfig e IngressClass, uma instância ALB é criada automaticamente.

    1. Crie um arquivo chamado alb.yaml e copie o conteúdo a seguir para ele.

      O arquivo alb.yaml cria os recursos AlbConfig e IngressClass.

      apiVersion: alibabacloud.com/v1
kind: AlbConfig
metadata:
  name: alb-demo
spec:
  config:
    name: alb-test             # The name of the ALB instance.
    addressType: Internet      # Use 'Internet' for public-facing or 'Intranet' for private.
    zoneMappings:
    - vSwitchId: vsw-wz9e2usil7e5an1xi****    # Specify vSwitch IDs in at least two zones.
    - vSwitchId: vsw-wz92lvykqj1siwvif****
  listeners:
    - port: 80
      protocol: HTTP
---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb
spec:
  controller: ingress.k8s.alibabacloud/alb
  parameters:
    apiGroup: alibabacloud.com
    kind: AlbConfig
    name: alb-demo   # The referenced AlbConfig resource.
      Nota

      Atente-se aos seguintes parâmetros:

      • albconfig.spec.config.addressType: Tipo de rede da instância. Valores válidos:

        • Internet (padrão): Cria uma instância voltada para a internet pública. Um IP público e um IP privado são atribuídos a cada zona. Instâncias ALB públicas usam um elastic IP address (EIP) para fornecer serviços pela internet. São cobradas taxas de instância e de transferência de dados para o EIP.

          • O EIP fornece acesso à internet pública para a instância ALB.

          • O IP privado permite o acesso à instância ALB a partir de instâncias ECS dentro da mesma VPC.

        • Intranet: Cria uma instância privada. Um IP privado é atribuído a cada zona. A instância ALB fica acessível apenas pela rede do Alibaba Cloud e não pode ser alcançada pela internet.

      • spec.config.zoneMappings: Especifica os IDs dos vSwitches para o ALB Ingress. Informe pelo menos dois IDs de vSwitches em zonas diferentes. Os vSwitches especificados devem estar em zonas suportadas pela instância ALB atual. Para mais informações sobre as regiões e zonas suportadas pelo ALB, consulte Regiões e zonas suportadas.

    2. Conecte-se ao cluster via kubectl e execute o comando a seguir para aplicar o arquivo alb.yaml.

      kubectl apply -f alb.yaml

      Saída esperada:

      AlbConfig.alibabacloud.com/alb-demo created
ingressclass.networking.k8s.io/alb created

    3. Verifique a criação da instância ALB.

      • Método 1: Execute o comando abaixo para visualizar o ID da instância ALB.

        kubectl get albconfig alb-demo     
        [root@i-xxx nuoZ test]# kubectl get albconfig alb-demo
NAME        ALBID                      DNSNAME                                          PORT&PROTOCOL   CERTID   AGE
alb-demo    alb-3lzokczr3c9guq7zz7    alb-3xxx.com                                                               84s

      • Método 2: Acesse o ALB console para visualizar a instância ALB criada.

        Nota

        Faça login no console com a conta Alibaba Cloud configurada no ConfigMap na Etapa 1: Implantar o alb-ingress-controller.

    Etapa 3: Implantar uma aplicação de teste

    Esta seção orienta o uso de uma imagem de teste para criar recursos de Deployment e implantar uma aplicação de teste.

    1. Crie um arquivo chamado test-service.yaml e copie o conteúdo a seguir para ele.

      O arquivo test-service.yaml implanta dois Deployments chamados test01 e test02, além de dois Services chamados test01-service e test02-service.

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: test01
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test01
  template:
    metadata:
      labels:
        app: test01
    spec:
      containers:
      - name: test01
        image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: test01-service
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: test01
  type: NodePort
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: test02
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test02
  template:
    metadata:
      labels:
        app: test02
    spec:
      containers:
      - name: test02
        image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: test02-service
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: test02
  type: NodePort

    2. Conecte-se ao cluster usando kubectl e execute o comando a seguir para aplicar o arquivo test-service.yaml.

      kubectl apply -f test-service.yaml

      Saída esperada:

      deployment.apps/test01 created
service/test01-service created
deployment.apps/test02 created
service/test02-service created

    3. Execute o comando abaixo para confirmar que os serviços de teste foram implantados com sucesso.

      kubectl get svc,deploy

      A saída a seguir indica que os serviços de teste foram implantados corretamente.

      [root@iZ2z***uoZ test]# kubectl get svc,deploy
NAME                        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/cloud-nodeport      NodePort    10.xxx.122      <none>        80:31310/TCP     63d
service/kubernetes          ClusterIP   10.xxx.1        <none>        443/TCP          63d
service/test01-service      NodePort    10.xxx.121      <none>        80:31254/TCP     9s
service/test02-service      NodePort    10.xxx.118      <none>        80:30337/TCP     9s
NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/openresty-deployment        2/2     2            2           63d
deployment.apps/test01                      2/2     2            2           9s
deployment.apps/test02                      1/1     1            1           9s

    Etapa 4: Criar um Ingress

    Um Ingress corresponde a uma regra de encaminhamento em uma instância ALB. Este tópico usa roteamento baseado em caminho. Para mais informações sobre recursos avançados, consulte o Guia de usuário do ALB Ingress.

    1. Crie um arquivo chamado test-ingress.yaml e copie o conteúdo a seguir para ele.

      O arquivo test-ingress.yaml cria um Ingress.

      apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
spec:
  ingressClassName: alb
  rules:
   - host: demo.domain.ingress.top
     http:
      paths:
      - path: /test01
        pathType: Prefix
        backend:
          service:
            name: test01-service
            port:
              number: 80
      - path: /test02
        pathType: Prefix
        backend:
          service:
            name: test02-service
            port:
              number: 80

    2. Conecte-se ao cluster via kubectl e execute o comando a seguir para aplicar o arquivo test-ingress.yaml.

      kubectl apply -f test-ingress.yaml

      Saída esperada:

      ingress.networking.k8s.io/test-ingress created

    3. Execute o comando abaixo para verificar a criação do recurso test-ingress.

      kubectl get ingress

      A saída a seguir indica que o recurso test-ingress foi criado com sucesso.

      [root@iZ2zxxx test]# kubectl get ingress
NAME           CLASS   HOSTS                    ADDRESS                                                        PORTS   AGE
test-ingress   alb     demo.domain.ingress.top  alb-xxx.cn-beijing.alb.aliyuncs.com   80      19s

    Etapa 5: Verificar os resultados

    Acesso por nome de domínio

    1. Crie um registro CNAME para mapear seu nome de domínio ao nome DNS da instância ALB. Para mais informações, consulte Configurar um registro CNAME para uma instância ALB.

      Neste exemplo, suponha que você mapeie o nome de domínio personalizado demo.domain.ingress.top para o nome DNS público da instância ALB.

    2. Execute o comando a seguir para acessar o serviço test01 por meio da instância ALB.

      curl http://demo.domain.ingress.top/test01

      O pod de backend NGINX retorna uma resposta com detalhes como Endereço do servidor (10.xxx.xxx.xxx:80), Nome do servidor (test01-648bf46944-kvlhj), Data (07/Nov/2022:08:16:35 +0000) e URI (/test01). Isso confirma que o Ingress roteou corretamente a requisição para um pod de backend do serviço test01.

    3. Execute o comando a seguir para acessar o serviço test02 por meio da instância ALB.

      curl http://demo.domain.ingress.top/test02

      O comando retorna a página de teste do NGINX, mostrando que o Endereço do servidor é 10.xxx.20:80, o Nome do servidor é test02-76d96f7b8d-6mtnn e a URI é /test02. Isso confirma que o Ingress roteou corretamente a requisição para o pod de backend test02.

    Em caso de dúvidas, participe do Grupo de Clientes ALB (DingTalk ID: 31945843) para obter assistência.

    Documentos relacionados

    Visão geral e recursos do ALB Ingress:

    Documentação do código-fonte: