Application Load Balancer da AWS Visão geral do Ingress do Cilium e do Gateway do Cilium Comparação entre Ingress e Gateway do Cilium Instale o Gateway do Cilium Configurar o Gateway do Cilium Implantar o Gateway do Cilium Instale o Ingress do Cilium Configurar o Ingress do Cilium Implementar o Ingress do Cilium Tipo de serviço LoadBalancer Tipo de serviço NodePort Rede do host

Configurar o Ingress do Kubernetes para nós híbridos

Este tópico descreve como configurar o Ingress do Kubernetes para workloads em execução no Amazon EKS Hybrid Nodes. O Ingress do Kubernetes expõe rotas HTTP e HTTPS de fora do cluster para os serviços dentro do cluster. Para usar os recursos do Ingress, é necessário um controlador do Ingress do Kubernetes para configurar a infraestrutura de rede e os componentes que atendem ao tráfego da rede.

A AWS oferece suporte para o AWS Application Load Balancer (ALB) e Cilium para Ingress do Kubernetes para workloads em execução no EKS Hybrid Nodes. A decisão de usar o ALB ou o Cilium para o Ingress é baseada na origem do tráfego da aplicação. Se o tráfego da aplicação for originário de uma região da AWS, a AWS recomenda usar o AWS ALB e o AWS Load Balancer Controller. Se o tráfego da aplicação for originado do ambiente on-premises ou da borda, a AWS recomenda usar os recursos de entrada integrados do Cilium, que podem ser usados com ou sem a infraestrutura de balanceador de carga em seu ambiente.

Application Load Balancer da AWS

Você pode usar o AWS Load Balancer Controller e o Application Load Balancer (ALB) com o tipo de destino ip para workloads executadas em nós híbridos. Ao usar o tipo de destino ip, o ALB encaminha o tráfego diretamente para os pods, ignorando o caminho de rede da camada de serviço. Para que o ALB alcance os destinos IP do pod on-premises em nós híbridos, o CIDR do pod on-premises deverá ser roteável em sua rede on-premises. Além disso, o AWS Load Balancer Controller usa webhooks e requer comunicação direta do ambiente de gerenciamento EKS. Para obter mais informações, consulte Configurar webhooks para nós híbridos.

Considerações

Consulte Roteamento de aplicações e tráfego HTTP com Application Load Balancers e Instale o AWS Load Balancer Controller com o Helm para obter mais informações sobre o AWS Application Load Balancer e o AWS Load Balancer Controller.
Consulte Práticas recomendadas para balanceamento de carga para obter informações sobre como escolher entre o AWS Application Load Balancer e o AWS Network Load Balancer.
Consulte Anotações do Ingress do AWS Load Balancer Controller para ver a lista de anotações que podem ser configuradas para recursos do Ingress com o AWS Application Load Balancer.

Pré-requisitos

Cilium instalado seguindo as instruções em Configurar a CNI para nós híbridos.
O ambiente de gerenciamento BGP do Cilium é habilitado seguindo as instruções em Configurar o BGP do Cilium para nós híbridos. Se você não quiser usar o BGP, deverá usar um método alternativo para tornar os CIDRs do pod on-premises roteáveis em sua rede on-premises. Se você não tornar seus CIDRs de pod on-premises roteáveis, o ALB não poderá registrar ou contatar seus destinos IP de pod.
O Helm instalado em seu ambiente de linha de comando. Consulte as Instruções de configuração do Helm para obter mais informações.
O eksctl instalado em seu ambiente de linha de comando. Consulte as instruções de instalação do eksctl para obter mais informações.

Procedimento

Baixe uma política do IAM para o AWS Load Balancer Controller que permita que ele faça chamadas para APIs da AWS em seu nome.


curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/refs/heads/main/docs/install/iam_policy.json

Crie uma política do IAM usando a política obtida por download na etapa anterior.


aws iam create-policy \
    --policy-name AWSLoadBalancerControllerIAMPolicy \
    --policy-document file://iam_policy.json

Substitua os valores do nome do cluster (CLUSTER_NAME), região da AWS (AWS_REGION) e ID da conta da AWS (AWS_ACCOUNT_ID) pelas suas configurações e execute o comando a seguir.


eksctl create iamserviceaccount \
    --cluster=CLUSTER_NAME \
    --namespace=kube-system \
    --name=aws-load-balancer-controller \
    --attach-policy-arn=arn:aws:iam::AWS_ACCOUNT_ID:policy/AWSLoadBalancerControllerIAMPolicy \
    --override-existing-serviceaccounts \
    --region AWS_REGION \
    --approve

Adicione o repositório de chart do Helm do eks-charts e atualize o repositório Helm local para garantir que você tenha os gráficos mais recentes.
```
helm repo add eks https://aws.github.io/eks-charts
```
```
helm repo update eks
```
Instale o AWS Load Balancer Controller. Substitua os valores do nome do cluster (CLUSTER_NAME), região da AWS (AWS_REGION), ID da VPC (VPC_ID) e versão do chart do Helm do AWS Load Balancer Controller (AWS_LBC_HELM_VERSION) pelas suas configurações e execute o comando a seguir. Se você estiver executando um cluster em modo misto com nós híbridos e nós na Nuvem AWS, você pode executar o AWS Load Balancer Controller nos nós da nuvem seguindo as instruções em AWS Load Balancer Controller.
- Você pode encontrar a versão mais recente do chart do Helm executando helm search repo eks/aws-load-balancer-controller --versions.
```
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
  -n kube-system \
  --version AWS_LBC_HELM_VERSION \
  --set clusterName=CLUSTER_NAME \
  --set region=AWS_REGION \
  --set vpcId=VPC_ID \
  --set serviceAccount.create=false \
  --set serviceAccount.name=aws-load-balancer-controller
```

Verifique se o AWS Load Balancer Controller foi instalado com êxito.


kubectl get -n kube-system deployment aws-load-balancer-controller


NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   2/2     2            2           84s

Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Crie um arquivo denominado my-ingress-alb.yaml com os conteúdos a seguir.


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
  annotations:
    alb.ingress.kubernetes.io/load-balancer-name: "my-ingress-alb"
    alb.ingress.kubernetes.io/target-type: "ip"
    alb.ingress.kubernetes.io/scheme: "internet-facing"
    alb.ingress.kubernetes.io/healthcheck-path: "/details/1"
spec:
  ingressClassName: alb
  rules:
  - http:
      paths:
      - backend:
          service:
            name: details
            port:
              number: 9080
        path: /details
        pathType: Prefix

Aplique a configuração do Ingress ao seu cluster.
```
kubectl apply -f my-ingress-alb.yaml
```
O provisionamento do ALB para o recurso do Ingress pode demorar alguns minutos. Depois que o ALB for provisionado, seu recurso do Ingress terá um endereço atribuído a ele que corresponde ao nome DNS da implantação do ALB. O endereço terá o formato <alb-name>-<random-string>.<region>.elb.amazonaws.com.
```
kubectl get ingress my-ingress
```
```
NAME         CLASS   HOSTS   ADDRESS                                                     PORTS   AGE
my-ingress   alb     *       my-ingress-alb-<random-string>.<region>.elb.amazonaws.com   80      23m
```

Acesse o serviço usando o endereço do ALB.


curl -s http//my-ingress-alb-<random-string>.<region>.elb.amazonaws.com:80/details/1 | jq


{
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
  "details": "This is the details page"
}

Visão geral do Ingress do Cilium e do Gateway do Cilium

Os recursos de entrada do Cilium são incorporados à arquitetura do Cilium e podem ser gerenciados com a API do Ingress do Kubernetes ou a API do Gateway. Se você não tem recursos do Ingress existentes, a AWS recomenda começar com a API do Gateway, pois é uma forma mais expressiva e flexível de definir e gerenciar os recursos de rede do Kubernetes. A API do Gateway do Kubernetes visa padronizar como os recursos de rede para Ingress, balanceamento de carga e malha de serviços são definidos e gerenciados nos clusters do Kubernetes.

Quando você habilita atributos do Ingress ou do Gateway do Cilium, o operador do Cilium reconcilia os objetos do Ingress ou Gateway no cluster e os proxies Envoy em cada nó processam o tráfego de rede da Camada 7 (L7). O Cilium não provisiona diretamente a infraestrutura Ingress ou Gateway, como balanceadores de carga. Se você planeja usar o Ingress do Cilium/Gateway com um balanceador de carga, deve usar as ferramentas do balanceador de carga, geralmente um controlador Ingress ou Gateway, para implantar e gerenciar a infraestrutura do balanceador de carga.

Para tráfego de Ingress ou Gateway, o Cilium lida com o tráfego da rede principal e a aplicação da política L3/L4, e os proxies Envoy integrados processam o tráfego de rede de L7. Com o Ingress do Cilium/Gateway, o Envoy é responsável por aplicar regras, políticas e manipulação de solicitações de roteamento L7, gerenciamento avançado de tráfego, como divisão e espelhamento de tráfego, e terminação e originação de TLS. Os proxies Envoy do Cilium são implantados como um DaemonSet (cilium-envoy) separado por padrão, o que permite que o Envoy e o atendente do Cilium sejam atualizados, escalados e gerenciados separadamente.

Para obter mais informações sobre como o Ingress do Cilium e o Gateway do Cilium funcionam, consulte as páginas Ingress do Cilium e Gateway do Cilium na documentação do Cilium.

Comparação entre Ingress e Gateway do Cilium

A tabela abaixo resume os recursos do Ingress do Cilium e do Gateway do Cilium a partir da versão 1.17.x do Cilium.

Recurso	Ingress	Gateway
Tipo de serviço LoadBalancer	Sim	Sim
Tipo de serviço NodePort	Sim	Não¹
Rede do host	Sim	Sim
Balanceador de carga compartilhado	Sim	Sim
Balanceador de carga dedicado	Sim	Número²
Políticas de rede	Sim	Sim
Protocolos	Camada 7 (HTTP(S), gRPC)	Camada 7 (HTTP(S), gRPC)³
Passagem do TLS	Sim	Sim
Gerenciamento de tráfego	Roteamento de caminhos e hosts	Roteamento de caminho e host, redirecionamento e reescrita de URL, divisão de tráfego, modificação de cabeçalho

¹ O suporte do Gateway do Cilium para serviços NodePort está planejado para a versão 1.18.x do Cilium (#27273)

² Suporte do Gateway do Cilium para balanceadores de carga dedicados (#25567)

³ Suporte do Gateway do Cilium para TCP/UDP (#21929)

Instale o Gateway do Cilium

Considerações

O Cilium deve ser configurado com nodePort.enabled definido como true, conforme mostrado nos exemplos abaixo. Se você estiver usando o atributo de substituição de kube-proxy do Cilium, não precisará definir nodePort.enabled como true.
O Cilium deve ser configurado com envoy.enabled definido como true, conforme mostrado nos exemplos abaixo.
O Gateway do Cilium pode ser implantado no balanceador de carga (padrão) ou no modo de rede host.
Ao usar o Gateway do Cilium no modo balanceador de carga, a anotação service.beta.kubernetes.io/aws-load-balancer-type: "external" deve ser definida no recurso do Gateway para evitar que o provedor de, nuvem AWS herdado crie um Classic Load Balancer para o serviço do tipo LoadBalancer que o Cilium cria para o recurso do Gateway.
Ao usar o Gateway do Cilium no modo de rede do host, o serviço do tipo LoadBalancer é desabilitado. O modo de rede do host é útil para ambientes que não têm infraestrutura de balanceador de carga, consulte Rede do host para obter mais informações.

Pré-requisitos

O Helm foi instalado em seu ambiente de linha de comando. Consulte as Instruções de configuração do Helm.
Cilium instalado seguindo as instruções em Configurar a CNI para nós híbridos.

Procedimento

Instale as definições de recursos personalizados (CRDs) da API do Gateway do Kubernetes.


kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gatewayclasses.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_gateways.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_httproutes.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_referencegrants.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.2.1/config/crd/standard/gateway.networking.k8s.io_grpcroutes.yaml

Crie um arquivo chamado cilium-gateway-values.yaml com o conteúdo a seguir. O exemplo abaixo configura o Gateway do Cilium para usar o modo padrão do balanceador de carga e usar um DaemonSet cilium-envoy separado para proxies Envoy configurados para serem executados somente em nós híbridos.


gatewayAPI:
  enabled: true
  # uncomment to use host network mode
  # hostNetwork:
  #   enabled: true
nodePort:
  enabled: true
envoy:
  enabled: true
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: eks.amazonaws.com/compute-type
            operator: In
            values:
            - hybrid

Aplique o arquivo de valores do Helm ao seu cluster.


helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
  --namespace kube-system \
  --reuse-values \
  --set operator.rollOutPods=true \
  --values cilium-gateway-values.yaml

Confirme se o operador, o atendente e os pods do Envoy do Cilium estão funcionando.


kubectl -n kube-system get pods --selector=app.kubernetes.io/part-of=cilium


NAME                               READY   STATUS    RESTARTS   AGE
cilium-envoy-5pgnd                 1/1     Running   0          6m31s
cilium-envoy-6fhg4                 1/1     Running   0          6m30s
cilium-envoy-jskrk                 1/1     Running   0          6m30s
cilium-envoy-k2xtb                 1/1     Running   0          6m31s
cilium-envoy-w5s9j                 1/1     Running   0          6m31s
cilium-grwlc                       1/1     Running   0          4m12s
cilium-operator-68f7766967-5nnbl   1/1     Running   0          4m20s
cilium-operator-68f7766967-7spfz   1/1     Running   0          4m20s
cilium-pnxcv                       1/1     Running   0          6m29s
cilium-r7qkj                       1/1     Running   0          4m12s
cilium-wxhfn                       1/1     Running   0          4m1s
cilium-z7hlb                       1/1     Running   0          6m30s

Configurar o Gateway do Cilium

O Gateway do Cilium é habilitado em objetos do Gateway definindo gatewayClassName como cilium. O serviço que o Cilium cria para recursos do Gateway pode ser configurado com campos no objeto Gateway. As anotações comuns usadas pelos controladores do Gateway para configurar a infraestrutura do balanceador de carga podem ser configuradas com o campo infrastructure do objeto do Gateway. Ao usar o IPAM de LoadBalancer do Cilium (veja o exemplo em Tipo de serviço LoadBalancer), o endereço IP a ser usado para o serviço do tipo LoadBalancer pode ser configurado no campo addresses do objeto do Gateway. Para obter mais informações sobre a configuração do Gateway, consulte a especificação da API do Gateway do Kubernetes.


apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: cilium
  infrastructure:
    annotations:
      service.beta.kubernetes.io/...
      service.kuberentes.io/...
  addresses:
  - type: IPAddress
    value: <LoadBalancer IP address>
  listeners:
  ...

O Cilium e a especificação do Kubernetes Gateway oferecem suporte aos recursos GatewayClass, Gateway, HTTPRoute, GRPCRoute e ReferenceGrant.

Consulte as especificações HTTPRoute e GRPCRoute para ver a lista de campos disponíveis.
Veja os exemplos na seção Implantar o Gateway do Cilium abaixo e os exemplos na documentação do Cilium para saber como usar e configurar esses recursos.

Implantar o Gateway do Cilium

Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Verifique se a aplicação está sendo executada com êxito.


kubectl get pods


NAME                              READY   STATUS    RESTARTS   AGE
details-v1-766844796b-9965p       1/1     Running   0          81s
productpage-v1-54bb874995-jmc8j   1/1     Running   0          80s
ratings-v1-5dc79b6bcd-smzxz       1/1     Running   0          80s
reviews-v1-598b896c9d-vj7gb       1/1     Running   0          80s
reviews-v2-556d6457d-xbt8v        1/1     Running   0          80s
reviews-v3-564544b4d6-cpmvq       1/1     Running   0          80s

Crie um arquivo denominado my-gateway.yaml com os conteúdos a seguir. O exemplo abaixo usa a anotação service.beta.kubernetes.io/aws-load-balancer-type: "external" para impedir que o provedor de nuvem AWS herdado crie um Classic Load Balancer para o serviço do tipo LoadBalancer que o Cilium cria para o recurso do Gateway.


---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: cilium
  infrastructure:
    annotations:
      service.beta.kubernetes.io/aws-load-balancer-type: "external"
  listeners:
  - protocol: HTTP
    port: 80
    name: web-gw
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-app-1
spec:
  parentRefs:
  - name: my-gateway
    namespace: default
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /details
    backendRefs:
    - name: details
      port: 9080

Aplique o recurso do Gateway ao seu cluster.
```
kubectl apply -f my-gateway.yaml
```

Confirme se o recurso do Gateway e o serviço correspondente foram criados. Nesse estágio, espera-se que o campo ADDRESS do recurso do Gateway não seja preenchido com um endereço IP ou nome de host e que o serviço do tipo LoadBalancer para o recurso do Gateway também não tenha um endereço IP ou nome de host atribuído.


kubectl get gateway my-gateway


NAME         CLASS    ADDRESS   PROGRAMMED   AGE
my-gateway   cilium             True         10s


kubectl get svc cilium-gateway-my-gateway


NAME                        TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
cilium-gateway-my-gateway   LoadBalancer   172.16.227.247   <pending>     80:30912/TCP   24s

Continue para Tipo de serviço LoadBalancer para configurar o recurso do Gateway para usar um endereço IP alocado pelo IPAM do balanceador de carga do Cilium, e Tipo de serviço NodePort ou Rede do host para configurar o recurso do Gateway para usar endereços de rede NodePort ou host.

Instale o Ingress do Cilium

Considerações

O Cilium deve ser configurado com nodePort.enabled definido como true, conforme mostrado nos exemplos abaixo. Se você estiver usando o atributo de substituição de kube-proxy do Cilium, não precisará definir nodePort.enabled como true.
O Cilium deve ser configurado com envoy.enabled definido como true, conforme mostrado nos exemplos abaixo.
Com ingressController.loadbalancerMode definido como dedicated, o Cilium cria serviços dedicados para cada recurso do Ingress. Com ingressController.loadbalancerMode definido como shared, o Cilium cria um serviço compartilhado do tipo LoadBalancer para todos os recursos do Ingress no cluster. Ao usar o modo shared do balanceador de carga, as configurações do serviço compartilhado, como labels, annotations, type e loadBalancerIP, são definidas na seção ingressController.service dos valores do Helm. Consulte a referência de valores Helm do Cilium para obter mais informações.
Com ingressController.default definido como true, o Cilium é configurado como o controlador de padrão do Ingress para o cluster e criará entradas do Ingress mesmo quando ingressClassName não estiver especificado nos recursos do Ingress.
O Ingress do Cilium pode ser implantado no balanceador de carga (padrão), na porta do nó ou no modo de rede host. Quando o Cilium é instalado no modo de rede host, os modos de serviço do tipo LoadBalancer e de serviço do tipo NodePort são desabilitados. Consulte Rede do host para obter mais informações.
Sempre defina ingressController.service.annotations como service.beta.kubernetes.io/aws-load-balancer-type: "external" nos valores do Helm para evitar que o provedor de nuvem AWS herdado crie um Classic Load Balancer para o serviço padrão cilium-ingress criado pelo chart do Helm do Cilium.

Pré-requisitos

O Helm foi instalado em seu ambiente de linha de comando. Consulte as Instruções de configuração do Helm.
Cilium instalado seguindo as instruções em Configurar a CNI para nós híbridos.

Procedimento

Crie um arquivo chamado cilium-ingress-values.yaml com o conteúdo a seguir. O exemplo abaixo configura o Ingress do Cilium para usar o modo dedicated do balanceador de carga padrão e usar um DaemonSet separado cilium-envoy para Envoy, proxies configurados para serem executados somente em nós híbridos.


ingressController:
  enabled: true
  loadbalancerMode: dedicated
  service:
    annotations:
      service.beta.kubernetes.io/aws-load-balancer-type: "external"
nodePort:
  enabled: true
envoy:
  enabled: true
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: eks.amazonaws.com/compute-type
            operator: In
            values:
            - hybrid

Aplique o arquivo de valores do Helm ao seu cluster.


helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
  --namespace kube-system \
  --reuse-values \
  --set operator.rollOutPods=true \
  --values cilium-ingress-values.yaml

Confirme se o operador, o atendente e os pods do Envoy do Cilium estão funcionando.


kubectl -n kube-system get pods --selector=app.kubernetes.io/part-of=cilium


NAME                               READY   STATUS    RESTARTS   AGE
cilium-envoy-5pgnd                 1/1     Running   0          6m31s
cilium-envoy-6fhg4                 1/1     Running   0          6m30s
cilium-envoy-jskrk                 1/1     Running   0          6m30s
cilium-envoy-k2xtb                 1/1     Running   0          6m31s
cilium-envoy-w5s9j                 1/1     Running   0          6m31s
cilium-grwlc                       1/1     Running   0          4m12s
cilium-operator-68f7766967-5nnbl   1/1     Running   0          4m20s
cilium-operator-68f7766967-7spfz   1/1     Running   0          4m20s
cilium-pnxcv                       1/1     Running   0          6m29s
cilium-r7qkj                       1/1     Running   0          4m12s
cilium-wxhfn                       1/1     Running   0          4m1s
cilium-z7hlb                       1/1     Running   0          6m30s

Configurar o Ingress do Cilium

O Ingress do Cilium é habilitado em objetos do Ingress definindo ingressClassName como cilium. Os serviços que o Cilium cria para os recursos do Ingress podem ser configurados com anotações nos objetos do Ingress ao usar o modo dedicated do de balanceador de carga, assim como na configuração do Cilium ou Helm ao usar o modo shared do balanceador de carga. Essas anotações são comumente usadas pelos controladores do Ingress para configurar a infraestrutura do balanceador de carga ou outros atributos do serviço, como tipo de serviço, modo do balanceador de carga, portas e passagem TLS. As anotações principais são descritas abaixo. Para obter uma lista completa das anotações compatíveis, consulte as Anotações do Ingress do Cilium na documentação do Cilium.

Anotação	Descrição
`ingress.cilium.io/loadbalancer-mode`	`dedicated`: serviço dedicado do tipo LoadBalancer para cada recurso do Ingress (padrão). `shared`: serviço único do tipo LoadBalancer para todos os recursos do Ingress.
`ingress.cilium.io/service-type`	`LoadBalancer`: o serviço será do tipo LoadBalancer (padrão) `NodePort`: o serviço será do tipo NodePort.
`service.beta.kubernetes.io/aws-load-balancer-type`	`"external"`: evite que um provedor de nuvem da AWS antigo provisione o Classic Load Balancer para serviços do tipo LoadBalancer.
`lbipam.cilium.io/ips`	Lista de endereços IP a serem alocados do Cilium LoadBalancer IPAM

O Cilium e a especificação Ingress do Kubernetes oferecem suporte a regras de correspondência exatas, prefixas e específicas de implementação para caminhos de entrada. O Cilium oferece suporte para regex como sua regra de correspondência específica para a implementação. Para obter mais informações, consulte Tipos e precedência de caminhos de entrada e Exemplos de tipos de caminhos na documentação do Cilium e os exemplos na seção Implementar o Ingress do Cilium desta página.

Um exemplo de objeto do Ingress do Cilium é mostrado abaixo.


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    service.beta.kuberentes.io/...
    service.kuberentes.io/...
spec:
  ingressClassName: cilium
  rules:
  ...

Implementar o Ingress do Cilium

Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra Istio Bookinfo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Verifique se a aplicação está sendo executada com êxito.


kubectl get pods


NAME                              READY   STATUS    RESTARTS   AGE
details-v1-766844796b-9965p       1/1     Running   0          81s
productpage-v1-54bb874995-jmc8j   1/1     Running   0          80s
ratings-v1-5dc79b6bcd-smzxz       1/1     Running   0          80s
reviews-v1-598b896c9d-vj7gb       1/1     Running   0          80s
reviews-v2-556d6457d-xbt8v        1/1     Running   0          80s
reviews-v3-564544b4d6-cpmvq       1/1     Running   0          80s

Crie um arquivo denominado my-ingress.yaml com os conteúdos a seguir. O exemplo abaixo usa a anotação service.beta.kubernetes.io/aws-load-balancer-type: "external" para impedir que o provedor de nuvem AWS herdado crie um Classic Load Balancer para o serviço do tipo LoadBalancer que o Cilium cria para o recurso do Ingress.


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "external"
spec:
  ingressClassName: cilium
  rules:
  - http:
      paths:
      - backend:
          service:
            name: details
            port:
              number: 9080
        path: /details
        pathType: Prefix

Aplique o recurso do Ingress ao seu cluster.
```
kubectl apply -f my-ingress.yaml
```

Confirme se o recurso de entrada e o serviço correspondente foram criados. Nesse estágio, espera-se que o campo ADDRESS do recurso do Ingress não seja preenchido com um endereço IP ou nome de host e que o serviço compartilhado ou dedicado do tipo LoadBalancer para o recurso do Ingress também não tenha um endereço IP ou nome de host atribuído.


kubectl get ingress my-ingress


NAME         CLASS    HOSTS   ADDRESS   PORTS   AGE
my-ingress   cilium   *                 80      8s

Para o modo shared do balanceador de carga


kubectl -n kube-system get svc cilium-ingress


NAME             TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
cilium-ingress   LoadBalancer   172.16.217.48   <pending>     80:32359/TCP,443:31090/TCP   10m

Para o modo dedicated do balanceador de carga


kubectl -n default get svc cilium-ingress-my-ingress


NAME                        TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
cilium-ingress-my-ingress   LoadBalancer   172.16.193.15   <pending>     80:32088/TCP,443:30332/TCP   25s

Continue para Tipo de serviço LoadBalancer para configurar o recurso do Ingress para usar um endereço IP alocado pelo IPAM do balanceador de carga do Cilium, e Tipo de serviço NodePort ou Rede do host para configurar o recurso do Ingress para usar endereços de rede NodePort ou host.

Tipo de serviço LoadBalancer

Infraestrutura de balanceador de carga existente

Por padrão, tanto para o Ingress do Cilium quanto para o Gateway do Cilium, o Cilium cria serviços do Kubernetes do tipo LoadBalancer para os recursos do Ingress ou Gateway. Os atributos do(s) serviço(s) que o Cilium cria podem ser configurados por meio dos recursos do Ingress e do Gateway. Quando você cria recursos de Ingress ou Gateway, o endereço IP ou os nomes de host expostos externamente para o Ingress ou o Gateway são alocados da infraestrutura do balanceador de carga, que normalmente é provisionada por um controlador de Ingress ou Gateway.

Muitos controladores Ingress e Gateway usam anotações para detectar e configurar a infraestrutura do balanceador de carga. As anotações desses controladores Ingress e Gateway são configuradas nos recursos do Ingress ou do Gateway, conforme mostrado nos exemplos anteriores acima. Consulte a documentação do controlador do Ingress ou do Gateway para ver as anotações compatíveis e consulte a documentação do Ingress do Kubernetes e a documentação do Gateway do Kubernetes para ver uma lista dos controladores populares.

Importante

O Ingress e o Gateway do Cilium não podem ser usados com o AWS Load Balancer Controller e o AWS Network Load Balancers (NLBs) com o EKS Hybrid Nodes. A tentativa de usá-los juntos resulta em destinos não registrados, pois o NLB tenta se conectar diretamente aos IPs do pod que apoiam o serviço do tipo LoadBalancer quando o tipo target-type do NLB está definido como ip (requisito para usar o NLB com workloads em execução no EKS Hybrid Nodes).

Não há Infraestrutura de balanceador de carga

Se você não tiver uma infraestrutura de balanceador de carga e o controlador do Ingress ou Gateway correspondente em seu ambiente, os recursos do Ingress ou Gateway e os serviços correspondentes do tipo LoadBalancer podem ser configurados para usar endereços IP alocados pelo gerenciamento de endereços IP do balanceador de carga (LB IPAM) do Cilium. O IPAM de LB do Cilium pode ser configurado com intervalos de endereços IP conhecidos de seu ambiente on-premises e pode usar o suporte integrado ao Protocolo de Gateway da Borda (BGP) do Cilium ou anúncios L2 para anunciar os endereços IP do LoadBalancer em sua rede on-premises.

O exemplo abaixo mostra como configurar o LB IPAM do Cilium com um endereço IP para usar em seus recursos do Ingress ou Gateway e como configurar o ambiente de gerenciamento BGP do Cilium para anunciar o endereço IP do LoadBalancer na rede on-premises. O atributo LB IPAM do Cilium está habilitado por padrão, mas não será habilitado até a criação de um recurso CiliumLoadBalancerIPPool.

Pré-requisitos

Ingress do Cilium ou Gateway instalado seguindo as instruções em Instale o Ingress do Cilium ou Instale o Gateway do Cilium.
Recursos do Ingress ou Gateway do Cilium com a aplicação de amostra implantada seguindo as instruções em Implementar o Ingress do Cilium ou Implantar o Gateway do Cilium.
O ambiente de gerenciamento BGP do Cilium é habilitado seguindo as instruções em Configurar o BGP do Cilium para nós híbridos. Se você não quiser usar o BGP, poderá ignorar esse pré-requisito, mas não poderá acessar seu recurso de entrada ou gateway até que o endereço IP do LoadBalancer alocado pelo IPAM do Cilium LB seja roteável em sua rede on-premises.

Procedimento

Opcionalmente, corrija o recurso do Ingress ou Gateway para solicitar um endereço IP específico para usar no serviço do tipo LoadBalancer. Se você não solicitar um endereço IP específico, o Cilium alocará um endereço IP do intervalo de endereços IP configurado no recurso CiliumLoadBalancerIPPool na etapa subsequente. Nos comandos abaixo, substitua LB_IP_ADDRESS pelo endereço IP para solicitar o serviço do tipo LoadBalancer.

Gateway
```
kubectl patch gateway -n default my-gateway --type=merge -p '{
  "spec": {
    "addresses": [{"type": "IPAddress", "value": "LB_IP_ADDRESS"}]
  }
}'
```
Ingress
```
kubectl patch ingress my-ingress --type=merge -p '{
  "metadata": {"annotations": {"lbipam.cilium.io/ips": "LB_IP_ADDRESS"}}
}'
```
Crie um arquivo chamado cilium-lbip-pool-ingress.yaml com um recurso CiliumLoadBalancerIPPool para configurar o intervalo de endereços IP do balanceador de carga para seus recursos do Ingress ou Gateway.
- Se você estiver usando o Ingress do Cilium, o Cilium aplica automaticamente o rótulo cilium.io/ingress: "true" aos serviços que cria para os recursos do Ingress. Você pode usar esse rótulo no campo serviceSelector da definição do recurso CiliumLoadBalancerIPPool para selecionar os serviços elegíveis para o LB IPAM.
- Se você estiver usando o Gateway do Cilium, poderá usar o rótulo gateway.networking.k8s.io/gateway-name nos campos serviceSelector da definição do recurso CiliumLoadBalancerIPPool para selecionar os recursos do Gateway elegíveis para o LB IPAM.
- Substitua LB_IP_CIDR pelo intervalo de endereços IP a ser usado para os endereços IP do balanceador de carga. Para selecionar um único endereço IP, use um /32 CIDR. Para obter mais informações, consulte Gerenciamento de endereços IP do LoadBalancer na documentação do Cilium.
```
apiVersion: cilium.io/v2alpha1
kind: CiliumLoadBalancerIPPool
metadata:
  name: bookinfo-pool
spec:
  blocks:
  - cidr: "LB_IP_CIDR"
  serviceSelector:
    # if using Cilium Gateway
    matchExpressions:
      - { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
    # if using Cilium Ingress
    matchLabels:
      cilium.io/ingress: "true"
```
Aplique o recurso CiliumLoadBalancerIPPool ao seu cluster.
```
kubectl apply -f cilium-lbip-pool-ingress.yaml
```

Confirme se um endereço IP foi alocado por meio do LB IPAM do Colium para o recurso do Ingress ou Gateway.

Gateway


kubectl get gateway my-gateway


NAME         CLASS    ADDRESS        PROGRAMMED   AGE
my-gateway   cilium   LB_IP_ADDRESS    True         6m41s

Ingress


kubectl get ingress my-ingress


NAME         CLASS    HOSTS   ADDRESS        PORTS   AGE
my-ingress   cilium   *       LB_IP_ADDRESS   80      10m

Crie um arquivo nomeado como cilium-bgp-advertisement-ingress.yaml com um recurso CiliumBGPAdvertisement para anunciar o endereço IP do LoadBalancer para os recursos do Ingress ou Gateway. Se você não estiver usando o Cilium BGP, poderá ignorar esta etapa. O endereço IP do LoadBalancer usado para seu recurso do Ingress ou Gateway deve ser roteável em sua rede on-premises para que você possa consultar o serviço na próxima etapa.


apiVersion: cilium.io/v2alpha1
kind: CiliumBGPAdvertisement
metadata:
  name: bgp-advertisement-lb-ip
  labels:
    advertise: bgp
spec:
  advertisements:
    - advertisementType: "Service"
      service:
        addresses:
          - LoadBalancerIP
      selector:
        # if using Cilium Gateway
        matchExpressions:
          - { key: gateway.networking.k8s.io/gateway-name, operator: In, values: [ my-gateway ] }
        # if using Cilium Ingress
        matchLabels:
          cilium.io/ingress: "true"

Aplique o recurso CiliumBGPAdvertisement ao seu cluster.


kubectl apply -f cilium-bgp-advertisement-ingress.yaml

Acesse o serviço usando o endereço IP alocado pelo Cilium LB IPAM.


curl -s http://LB_IP_ADDRESS:80/details/1 | jq


{
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
}

Tipo de serviço NodePort

Se você não tiver infraestrutura de balanceador de carga e controlador de entrada correspondente em seu ambiente, ou se estiver autogerenciando sua infraestrutura de balanceador de carga ou usando balanceamento de carga baseado em DNS, você pode configurar o Ingress do Cilium para criar serviços do tipo NodePort para os recursos do Ingress. Ao usar o NodePort com o Ingress do Cilium, o serviço do tipo NodePort é exposto em uma porta em cada nó no intervalo de portas 30000-32767. Nesse modo, quando o tráfego chega a qualquer nó no cluster no NodePort, ele é encaminhado para um pod que faz o backup do serviço, que pode estar no mesmo nó ou em um nó diferente.

nota

O suporte do Gateway do Cilium para serviços NodePort está planejado para a versão 1.18.x (#27273)

Pré-requisitos

O Ingress do Cilium foi instalado seguindo as instruções em Instale o Ingress do Cilium.
Recursos do Ingress do Cilium com aplicação de amostra implantada seguindo as instruções em Implementar o Ingress do Cilium.

Procedimento

Corrija o recurso do Ingress existente my-ingress para alterá-lo do tipo de serviço LoadBalancer para NodePort.


kubectl patch ingress my-ingress --type=merge -p '{
    "metadata": {"annotations": {"ingress.cilium.io/service-type": "NodePort"}}
}'

Se você não criou o recurso do Ingress, poderá fazê-lo aplicando a seguinte definição do Ingress ao seu cluster. Observe que a definição do Ingress abaixo usa a aplicação de amostra Istio Bookinfo descrita em Implementar o Ingress do Cilium.


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "external"
    "ingress.cilium.io/service-type": "NodePort"
spec:
  ingressClassName: cilium
  rules:
  - http:
      paths:
      - backend:
          service:
            name: details
            port:
              number: 9080
        path: /details
        pathType: Prefix

Confirme se o serviço do recurso do Ingress foi atualizado para usar o tipo de serviço NodePort. Observe a porta do protocolo HTTP na saída. No exemplo abaixo, essa porta HTTP é 32353, que será usada em uma etapa subsequente para fazer uma consulta sobre o serviço. A vantagem de usar o Ingress do Cilium com serviço do tipo NodePort é que você pode aplicar roteamento baseado em caminho e host, bem como políticas de rede para o tráfego de entrada, o que você não pode fazer para um serviço padrão do tipo NodePort sem o Ingress.
```
kubectl -n default get svc cilium-ingress-my-ingress
```
```
NAME                        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
cilium-ingress-my-ingress   NodePort   172.16.47.153   <none>        80:32353/TCP,443:30253/TCP   27m
```

Obtenha os endereços IP dos nós do seu cluster.


kubectl get nodes -o wide


NAME                   STATUS   ROLES    AGE   VERSION               INTERNAL-IP     EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
mi-026d6a261e355fba7   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Acesse o serviço do tipo NodePort usando os endereços IP dos seus nós e o NodePort capturado acima. No exemplo abaixo, o endereço IP do nó usado é 10.80.146.32 e o NodePort é 32353. Substitua-os pelos valores para o seu ambiente.


curl -s http://10.80.146.32:32353/details/1 | jq


{
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
}

Rede do host

Semelhante ao serviço do tipo NodePort, se você não tiver uma infraestrutura de balanceador de carga e um controlador de entrada ou gateway, ou se estiver gerenciando automaticamente seu balanceamento de carga com um balanceador de carga externo, poderá configurar o Ingress do Cilium e o Gateway do Cilium para expor os recursos do Ingress e do Gateway diretamente na rede do host. Quando o modo de rede do host está habilitado para um recurso de entrada ou gateway, o serviço dos modos LoadBalancer e NodePort é automaticamente desabilitado. O modo de rede do host é mutuamente exclusivo com esses modos alternativos para cada recurso de entrada ou gateway. Comparado ao serviço do tipo NodePort, o modo de rede host oferece flexibilidade adicional para a variedade de portas que podem ser usadas (não está restrito ao intervalo 30000-32767 NodePort) e você pode configurar um subconjunto de nós em que os proxies Envoy são executados na rede do host.

Pré-requisitos

Ingress do Cilium ou Gateway instalado seguindo as instruções em Instale o Ingress do Cilium ou Instale o Gateway do Cilium.

Procedimento

Gateway

Crie um arquivo chamado cilium-gateway-host-network.yaml com o conteúdo a seguir.


gatewayAPI:
  enabled: true
  hostNetwork:
    enabled: true
    # uncomment to restrict nodes where Envoy proxies run on the host network
    # nodes:
    #   matchLabels:
    #     role: gateway

Aplique a configuração do Gateway do Cilium de rede do host ao seu cluster.
```
helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
  --namespace kube-system \
  --reuse-values \
  --set operator.rollOutPods=true \
  -f cilium-gateway-host-network.yaml
```
Se você não criou o recurso do Gateway, pode criá-lo aplicando a seguinte definição de Gateway ao seu cluster. A definição de Gateway abaixo usa a aplicação de amostra Istio Bookinfo descrita em Implantar o Gateway do Cilium. No exemplo abaixo, o recurso do Gateway está configurado para usar a porta 8111 do receptor HTTP, que é a porta compartilhada do receptor para os proxies Envoy em execução na rede do host. Se você estiver usando uma porta privilegiada (inferior a 1023) para o recurso do Gateway, consulte a documentação do Cilium para obter instruções.
```
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: cilium
  listeners:
  - protocol: HTTP
    port: 8111
    name: web-gw
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-app-1
spec:
  parentRefs:
  - name: my-gateway
    namespace: default
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /details
    backendRefs:
    - name: details
      port: 9080
```
Você pode observar a configuração aplicada do Cilium Envoy com o comando a seguir.
```
kubectl get cec cilium-gateway-my-gateway -o yaml
```
Você pode obter a porta do receptor Envoy para o serviço cilium-gateway-my-gateway com o comando a seguir. Neste exemplo, a porta compartilhada do receptor é 8111.
```
kubectl get cec cilium-gateway-my-gateway -o jsonpath={.spec.services[0].ports[0]}
```

Obtenha os endereços IP dos nós do seu cluster.


kubectl get nodes -o wide


NAME                   STATUS   ROLES    AGE   VERSION               INTERNAL-IP     EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
mi-026d6a261e355fba7   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Acesse o serviço usando os endereços IP dos seus nós e a porta do receptor do recurso cilium-gateway-my-gateway. No exemplo abaixo, o endereço IP do nó usado é 10.80.146.32 e a porta do receptor é 8111. Substitua-os pelos valores para o seu ambiente.


curl -s http://10.80.146.32:8111/details/1 | jq


{
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
}

Ingress

Devido a um problema de upstream do Cilium (#34028), o Ingress do Cilium no modo de rede do host requer o uso de loadbalancerMode: shared, o que cria um único serviço do tipo ClusterIP para todos os recursos do Ingress no cluster. Se você estiver usando uma porta privilegiada (inferior a 1023) para o recurso do Ingress, consulte a documentação do Cilium para obter instruções.

Crie um arquivo chamado cilium-ingress-host-network.yaml com o conteúdo a seguir.


ingressController:
  enabled: true
  loadbalancerMode: shared
  # This is a workaround for the upstream Cilium issue
  service:
    externalTrafficPolicy: null
    type: ClusterIP
  hostNetwork:
    enabled: true
    # ensure the port does not conflict with other services on the node
    sharedListenerPort: 8111
    # uncomment to restrict nodes where Envoy proxies run on the host network
    # nodes:
    #   matchLabels:
    #     role: ingress

Aplique a configuração do Ingress do Cilium em modo de rede do host ao seu cluster.


helm upgrade cilium oci://public.ecr.aws/eks/cilium/cilium \
  --namespace kube-system \
  --reuse-values \
  --set operator.rollOutPods=true \
  -f cilium-ingress-host-network.yaml

Se você não criou o recurso do Ingress, poderá fazê-lo aplicando a seguinte definição do Ingress ao seu cluster. A definição do Ingress abaixo usa a aplicação de amostra Istio Bookinfo descrita em Implementar o Ingress do Cilium.


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
spec:
  ingressClassName: cilium
  rules:
  - http:
      paths:
      - backend:
          service:
            name: details
            port:
              number: 9080
        path: /details
        pathType: Prefix

Você pode observar a configuração aplicada do Cilium Envoy com o comando a seguir.


kubectl get cec -n kube-system cilium-ingress -o yaml

Você pode obter a porta do receptor Envoy para o serviço cilium-ingress com o comando a seguir. Neste exemplo, a porta compartilhada do receptor é 8111.


kubectl get cec -n kube-system cilium-ingress -o jsonpath={.spec.services[0].ports[0]}

Obtenha os endereços IP dos nós do seu cluster.


kubectl get nodes -o wide


NAME                   STATUS   ROLES    AGE   VERSION               INTERNAL-IP     EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
mi-026d6a261e355fba7   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.150   <none>        Ubuntu 22.04.5 LTS   5.15.0-142-generic   containerd://1.7.27
mi-082f73826a163626e   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.32    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-09183e8a3d755abf6   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.33    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0d78d815980ed202d   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.97    <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27
mi-0daa253999fe92daa   Ready    <none>   23h   v1.32.3-eks-473151a   10.80.146.100   <none>        Ubuntu 22.04.4 LTS   5.15.0-142-generic   containerd://1.7.27

Acesse o serviço usando os endereços IP dos seus nós e a sharedListenerPort para o recurso cilium-ingress. No exemplo abaixo, o endereço IP do nó usado é 10.80.146.32 e a porta do receptor é 8111. Substitua-os pelos valores para o seu ambiente.


curl -s http://10.80.146.32:8111/details/1 | jq


{
  "id": 1,
  "author": "William Shakespeare",
  "year": 1595,
  "type": "paperback",
  "pages": 200,
  "publisher": "PublisherA",
  "language": "English",
  "ISBN-10": "1234567890",
  "ISBN-13": "123-1234567890"
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Configurar o BGP

Configurar os serviços LoadBalancer