Uso do kubectl para criar um ingress do ELB

Cenário

Esta seção usa uma carga de trabalho do Nginx como exemplo para descrever como criar um ingress de ELB usando o kubectl.

• Se nenhum balanceador de carga estiver disponível na mesma VPC, o CCE poderá criar automaticamente um balanceador de carga ao criar um ingress. Para mais detalhes, consulte Criar um ingress - criar automaticamente um balanceador de carga.
• Se um balanceador de carga estiver disponível na mesma VPC, execute a operação fazendo referência a Criar um ingress - interconectarse com um balanceador de carga existente.

Pré-requisitos

• Um ingress fornece acesso à rede para cargas de trabalho de back-end. Certifique-se de que uma carga de trabalho esteja disponível em um cluster. Se nenhuma carga de trabalho estiver disponível, implemente uma carga de trabalho de amostra do Nginx referindo-se a Criação de uma Implantação, Criação de um StatefulSet ou Criação de um DaemonSet.
• Serviços suportados por ingresses lista os Serviços suportados pelos ingresses do ELB.
• Os balanceadores de carga dedicados devem ser do tipo de aplicação (HTTP/HTTPS) que suportam redes privadas (com um IP privado).

Descrição de ingress de networking.k8s.io/v1

Em clusters do CCE de v1.23 ou posterior, a versão de ingress é comutada para networking.k8s.io/v1.

Comparada com v1beta1, v1 tem as seguintes diferenças nos parâmetros:

• O tipo de ingress é alterado de kubernetes.io/ingress.class em annotations para spec.ingressClassName.
• O formato do backend é alterado.
• O parâmetro pathType deve ser especificado para cada caminho. As opções são as seguintes:
  • ImplementationSpecific: o método de correspondência depende do Ingress Controller. O método de correspondência definido por ingress.beta.kubernetes.io/url-match-mode é usado no CCE, que é o mesmo que v1beta1.
  • Exact: correspondência exata do URL, que diferencia maiúsculas de minúsculas.
  • Prefix: correspondência com base no prefixo de URL separado por uma barra (/). A correspondência diferencia maiúsculas de minúsculas, e os elementos no caminho são correspondidos um a um. Um elemento path refere-se a uma lista de rótulos no caminho separados por uma barra (/).

Criar um ingress - criar automaticamente um balanceador de carga

A seguir, descrevemos como executar o comando kubectl para criar automaticamente um balanceador de carga ao criar um ingress.

1. Use o kubectl para se conectar ao cluster. Para mais detalhes, consulte Conexão a um cluster usando o kubectl.
2. Crie um arquivo YAML chamado ingress-test.yaml. O nome do arquivo pode ser personalizado.

   vi ingress-test.yaml

   

   A partir do cluster v1.23, a versão de entrada é alternada de networking.k8s.io/v1beta1 para networking.k8s.io/v1. Para obter detalhes sobre as diferenças entre v1 e v1beta1, consulte Descrição de ingress de networking.k8s.io/v1.

   Exemplo de um balanceador de carga compartilhado (acesso de rede pública) para clusters da v1.23 ou posterior:

   apiVersion: networking.k8s.io/v1
   kind: Ingress 
   metadata: 
     name: ingress-test
     annotations: 
       kubernetes.io/elb.class: union
       kubernetes.io/elb.port: '80'
       kubernetes.io/elb.autocreate: 
         '{
             "type":"public",
             "bandwidth_name":"cce-bandwidth-******",
             "bandwidth_chargemode":"bandwidth",
             "bandwidth_size":5,
             "bandwidth_sharetype":"PER",
             "eip_type":"5_bgp"
           }'
    spec:
     rules: 
     - host: ''
       http: 
         paths: 
         - path: '/'
           backend: 
             service:
               name: <your_service_name>  # Replace it with the name of your target Service.
               port: 
                 number: <your_service_port>  # Replace it with the port number of your target Service.
           property:
             ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH
           pathType: ImplementationSpecific
     ingressClassName: cce    # ELB ingress is used.

   Exemplo de um balanceador de carga compartilhado (acesso de rede pública) para clusters da v1.21 ou anterior:

   apiVersion: networking.k8s.io/v1beta1
   kind: Ingress 
   metadata: 
     name: ingress-test
     annotations: 
       kubernetes.io/elb.class: union
       kubernetes.io/ingress.class: cce    # ELB ingress is used.
       kubernetes.io/elb.port: '80'
       kubernetes.io/elb.autocreate: 
         '{
             "type":"public",
             "bandwidth_name":"cce-bandwidth-******",
             "bandwidth_chargemode":"bandwidth",
             "bandwidth_size":5,
             "bandwidth_sharetype":"PER",
             "eip_type":"5_bgp"
           }'
    spec:
     rules: 
     - host: ''
       http: 
         paths: 
         - path: '/'
           backend: 
             serviceName: <your_service_name>  # Replace it with the name of your target Service.
             servicePort: <your_service_port>  # Replace it with the port number of your target Service.
           property:
             ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH

   Exemplo de um balanceador de carga dedicado (acesso de rede pública) para clusters v1.23 ou posterior:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: ingress-test
     namespace: default
     annotations:
       kubernetes.io/elb.class: performance
       kubernetes.io/elb.port: '80'
       kubernetes.io/elb.autocreate: 
         '{
             "type": "public",
             "bandwidth_name": "cce-bandwidth-******",
             "bandwidth_chargemode": "bandwidth",
             "bandwidth_size": 5,
             "bandwidth_sharetype": "PER",
             "eip_type": "5_bgp",
             "available_zone": [
                 "ap-southeast-1a"
             ],
             "elb_virsubnet_ids":["b4bf8152-6c36-4c3b-9f74-2229f8e640c9"],
             "l7_flavor_name": "L7_flavor.elb.s1.small"
          }'
    spec:
     rules: 
     - host: ''
       http: 
         paths: 
         - path: '/'
           backend: 
             service:
               name: <your_service_name>  # Replace it with the name of your target Service.
               port: 
                 number: <your_service_port>  # Replace it with the port number of your target Service.
           property:
             ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH
           pathType: ImplementationSpecific
     ingressClassName: cce

   Exemplo de balanceador de carga dedicado (acesso de rede pública) para clusters da versão 1.21 ou anterior:

   apiVersion: networking.k8s.io/v1beta1
   kind: Ingress
   metadata:
     name: ingress-test
     namespace: default
     annotations:
       kubernetes.io/elb.class: performance
       kubernetes.io/ingress.class: cce
       kubernetes.io/elb.port: '80'
       kubernetes.io/elb.autocreate: 
         '{
             "type": "public",
             "bandwidth_name": "cce-bandwidth-******",
             "bandwidth_chargemode": "bandwidth",
             "bandwidth_size": 5,
             "bandwidth_sharetype": "PER",
             "eip_type": "5_bgp",
             "available_zone": [
                 "ap-southeast-1a"
             ],
             "elb_virsubnet_ids":["b4bf8152-6c36-4c3b-9f74-2229f8e640c9"],
             "l7_flavor_name": "L7_flavor.elb.s1.small"
          }'
    spec:
     rules:
     - host: ''
       http:
         paths:
         - path: '/'
           backend: 
             serviceName: <your_service_name>  # Replace it with the name of your target Service.
             servicePort: <your_service_port>  # Replace it with the port number of your target Service.
           property:
             ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH

   Tabela 1 Parâmetros principais

   Parâmetro	Obrigatório	Tipo	Descrição
   kubernetes.io/elb.class	Sim	String	Selecione um tipo adequado de balanceador de carga. O valor pode ser: union: balanceador de carga compartilhado performance: balanceador de carga dedicado. Para obter detalhes, consulte Diferenças entre balanceadores de carga compartilhados e dedicados. Padrão: union
   kubernetes.io/ingress.class	Sim (somente para clusters da v1.21 ou anterior)	String	cce: o ingress auto-desenvolvido do ELB é usado. Esse parâmetro é obrigatório quando uma entrada é criada chamando a API.
   ingressClassName	Sim (somente para clusters da v1.23 ou posterior)	String	cce: o ingress auto-desenvolvido do ELB é usado. Esse parâmetro é obrigatório quando um ingress é criado chamando a API.
   kubernetes.io/elb.port	Sim	Integer	Este parâmetro indica a porta externa registrada com o endereço do Serviço LoadBalancer. Intervalo suportado: 1 a 65535 NOTA: Algumas portas são portas de alto risco e são bloqueadas por padrão, por exemplo, a porta 21.
   kubernetes.io/elb.subnet-id	Nenhum	String	ID da sub-rede onde o cluster está localizado. O valor pode conter de 1 a 100 caracteres. Obrigatório quando um cluster v1.11.7-r0 ou anterior deve ser criado automaticamente. Opcional para clusters posteriores à v1.11.7-r0. É deixado em branco por padrão. Para obter detalhes sobre como obter o valor, consulteQual é a diferença entre a API de sub-rede da VPC e a API de sub-rede do OpenStack Neutron.
   kubernetes.io/elb.enterpriseID	Não	String	Os clusters do Kubernetes v1.15 e versões posteriores oferecem suporte a esse campo. Nos clusters do Kubernetes anteriores à v1.15, os balanceadores de carga são criados no projeto padrão por padrão. ID do projeto empresarial no qual o balanceador de carga será criado. O valor contém de 1 a 100 caracteres. Como obter: Faça logon no console de gerenciamento e escolha Enterprise > Project Management na barra de menu superior. Na lista exibida, clique no nome do projeto empresarial de destino e copie o ID na página de detalhes do projeto empresarial.
   kubernetes.io/elb.autocreate	Sim	elb.autocreate object	Se criar automaticamente um balanceador de carga associado a um ingress. Para obter detalhes sobre a descrição do campo, consulte Tabela 2. Exemplo Se um balanceador de carga de rede pública for criado automaticamente, defina esse parâmetro com o seguinte valor: {"type":"public","bandwidth_name":"cce-bandwidth-******","bandwidth_chargemode":"bandwidth","bandwidth_size":5,"bandwidth_sharetype":"PER","eip_type":"5_bgp","name":"james"} Se um balanceador de carga de rede privada for criado automaticamente, defina esse parâmetro com o seguinte valor: {"type":"inner","name":"A-location-d-test"}
   host	Não	String	Nome de domínio para acessar o Serviço. Por padrão, esse parâmetro é deixado em branco e o nome de domínio precisa ser totalmente correspondido. Certifique-se de que o nome de domínio tenha sido registrado e arquivado. Depois que uma regra de nome de domínio estiver configurada, você deve usar o nome de domínio para acesso.
   path	Sim	String	Caminho de rota definido pelo usuário. Todas as solicitações de acesso externo devem corresponder ao host e ao path. NOTA: O caminho de acesso adicionado aqui deve existir na aplicação back-end. Caso contrário, o encaminhamento falha. Por exemplo, o URL de acesso padrão da aplicação Nginx é /usr/share/nginx/html. Ao adicionar /test à política de encaminhamento de ingress, certifique-se de que o URL de acesso da sua aplicação Nginx contenha /usr/share/nginx/html/test. Caso contrário, o erro 404 será retornado.
   ingress.beta.kubernetes.io/url-match-mode	Não	String	Política de correspondência de rotas. Padrão: STARTS_WITH (correspondência de prefixo) Opções: EQUAL_TO: correspondência exata STARTS_WITH: correspondência de prefixo REGEX: correspondência de expressão regular
   pathType	Sim	String	Tipo de caminho. Este campo é suportado apenas por clusters de v1.23 ou posterior. ImplementationSpecific: o método de correspondência depende do Ingress Controller. O método de correspondência definido por ingress.beta.kubernetes.io/url-match-mode é usado no CCE. Exact: correspondência exata do URL, que diferencia maiúsculas de minúsculas. Prefix: correspondência de prefixo, que diferencia maiúsculas de minúsculas. Com esse método, o caminho do URL é separado em vários elementos por barras (/) e os elementos são correspondidos um por um. Se cada elemento no URL corresponder ao caminho, os subcaminhos do URL poderão ser roteados normalmente. NOTA: Durante a correspondência de prefixo, cada elemento deve ser exatamente correspondido. Se o último elemento do URL for a subcadeia do último elemento no caminho da solicitação, nenhuma correspondência será executada. Por exemplo, /foo/bar corresponde a /foo/bar/baz, mas não corresponde a /foo/barbaz. Quando elementos são separados por barras (/), se o URL ou o caminho da requisição termina com uma barra (/), a barra (/) no final é ignorada. Por exemplo, /foo/bar corresponde a /foo/bar/. Veja exemplos de correspondência de caminho de ingress.

   Tabela 2 Estrutura de dados de elb.autocreate

   Parâmetro	Obrigatório	Tipo	Descrição
   name	Não	String	Nome do balanceador de carga criado automaticamente. O valor pode conter de 1 a 64 caracteres. Somente letras, dígitos, sublinhados (_), hifens (-) e pontos (.) são permitidos. Padrão: cce-lb+service.UID
   type	Não	String	Tipo de rede do balanceador de carga. public: balanceador de carga de rede pública inner: balanceador de carga de rede privada Padrão: inner
   bandwidth_name	Sim para balanceadores de carga de rede pública	String	Nome da largura de banda. O valor padrão é cce-bandwidth-******. O valor pode conter de 1 a 64 caracteres. Somente letras, dígitos, sublinhados (_), hifens (-) e pontos (.) são permitidos.
   bandwidth_chargemode	Não	String	Modo de cobrança de largura de banda. bandwidth: cobrado pela largura de banda traffic: cobrado pelo tráfego Padrão: bandwidth
   bandwidth_size	Sim para balanceadores de carga de rede pública	Integer	Tamanho da largura de banda. O valor padrão é de 1 a 2000 Mbit/s. Configure este parâmetro com base na faixa de largura de banda permitida em sua região. O incremento mínimo para ajuste de largura de banda varia dependendo do intervalo de largura de banda. O incremento mínimo é de 1 Mbit/s se a largura de banda permitida não exceder 300 Mbit/s. O incremento mínimo é de 50 Mbit/s se a largura de banda permitida varia de 300 Mbit/s a 1000 Mbit/s. O incremento mínimo é de 500 Mbit/s se a largura de banda permitida exceder 1000 Mbit/s.
   bandwidth_sharetype	Sim para balanceadores de carga de rede pública	String	Modo de compartilhamento de largura de banda. PER: largura de banda dedicada
   eip_type	Sim para balanceadores de carga de rede pública	String	Tipo de EIP. 5_telcom: China Telecom 5_union: China Unicom 5_bgp: BGP dinâmico 5_sbgp: BGP estático
   vip_subnet_cidr_id	Não	String	Sub-rede onde o balanceador de carga está localizado. Este campo é suportado por clusters de v1.21 ou posterior. Se esse parâmetro não for especificado, o balanceador de carga do ELB e o cluster estarão na mesma sub-rede.
   available_zone	Sim	Array of strings	AZ onde o balanceador de carga está localizado. Você pode obter todas as AZs suportadas consultando a lista de AZ. Esse parâmetro está disponível apenas para balanceadores de carga compartilhados.
   l4_flavor_name	Sim	String	Nome do flavor do balanceador de carga da camada 4. Você pode obter todos os tipos suportados consultando a lista de flavors. Esse parâmetro está disponível apenas para balanceadores de carga compartilhados.
   l7_flavor_name	Não	String	Nome do flavor do balanceador de carga da camada-7. Você pode obter todos os tipos suportados consultando a lista de flavors. Esse parâmetro está disponível apenas para balanceadores de carga compartilhados. O valor deste parâmetro deve ser o mesmo de l4_flavor_name, ou seja, ambos são especificações elásticas ou especificações fixas.
   elb_virsubnet_ids	Não	Array of strings	Sub-rede onde o servidor back-end do balanceador de carga está localizado. Se esse parâmetro for deixado em branco, a sub-rede do cluster padrão será usada. Os balanceadores de carga ocupam um número diferente de endereços IP de sub-rede com base em suas especificações. Não use os blocos CIDR de sub-rede de outros recursos (como clusters e nós) como o bloco CIDR do balanceador de carga. Esse parâmetro está disponível apenas para balanceadores de carga compartilhados. Exemplo: "elb_virsubnet_ids": [ "14567f27-8ae4-42b8-ae47-9f847a4690dd" ]

3. Crie um ingress.

   kubectl create -f ingress-test.yaml

   Se forem exibidas informações semelhantes às seguintes, o ingress foi criado.

   ingress/ingress-test created

   kubectl get ingress

   Se informações semelhantes às seguintes forem exibidas, o ingress foi criado com êxito e a carga de trabalho está acessível.

   NAME             HOSTS     ADDRESS          PORTS   AGE
   ingress-test     *         121.**.**.**     80      10s

4. Digite http://121.**.**.**:80 na caixa de endereço do navegador para acessar a carga de trabalho (por exemplo, carga de trabalho do Nginx).

   121.**.**.** indica o endereço IP do balanceador de carga unificado.

Criar um ingress - interconectarse com um balanceador de carga existente

O CCE permite que você se conecte a um balanceador de carga existente ao criar um ingress.

• Os balanceadores de carga dedicados existentes devem ser do tipo de aplicação (HTTP/HTTPS) que suportam redes privadas (com um IP privado).

apiVersion: networking.k8s.io/v1
kind: Ingress 
metadata: 
  name: ingress-test
  annotations: 
    kubernetes.io/elb.id: <your_elb_id>  # Replace it with the ID of your existing load balancer.
    kubernetes.io/elb.ip: <your_elb_ip>  # Replace it with the IP of your existing load balancer.
    kubernetes.io/elb.class: performance  # Load balancer type
    kubernetes.io/elb.port: '80'
spec:
  rules: 
  - host: ''
    http: 
      paths: 
      - path: '/'
        backend: 
          service:
            name: <your_service_name>  # Replace it with the name of your target Service.
            port: 
              number: 8080             # Replace 8080 with the port number of your target Service.
        property:
          ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH
        pathType: ImplementationSpecific
  ingressClassName: cce               

Se a versão do cluster for 1.21 ou anterior, a configuração do arquivo YAML será a seguinte:

apiVersion: networking.k8s.io/v1beta1
kind: Ingress 
metadata: 
  name: ingress-test
  annotations: 
    kubernetes.io/elb.id: <your_elb_id>  # Replace it with the ID of your existing load balancer.
    kubernetes.io/elb.ip: <your_elb_ip>  # Replace it with the IP of your existing load balancer.
    kubernetes.io/elb.class: performance  # Load balancer type
    kubernetes.io/elb.port: '80'
    kubernetes.io/ingress.class: cce
spec:
  rules: 
  - host: ''
    http: 
      paths: 
      - path: '/'
        backend: 
          serviceName: <your_service_name>  # Replace it with the name of your target Service.
          servicePort: 80
        property:
          ingress.beta.kubernetes.io/url-match-mode: STARTS_WITH