**Ajudar a melhorar esta página**
Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.
# 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](https://kubernetes.io/docs/concepts/services-networking/ingress/) 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.
![\[Ingress do EKS Hybrid Nodes\]](http://docs.aws.amazon.com/pt_br/eks/latest/userguide/images/hybrid-nodes-ingress.png)
## Application Load Balancer da AWS
Você pode usar o [AWS Load Balancer Controller](aws-load-balancer-controller.md) 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](hybrid-nodes-webhooks.md).
### Considerações
+ Consulte [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) e [Instale o AWS Load Balancer Controller com o Helm](lbc-helm.md) 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](https://docs.aws.amazon.com/eks/latest/best-practices/load-balacing.html) 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](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/) 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](hybrid-nodes-cni.md).
+ O ambiente de gerenciamento BGP do Cilium é habilitado seguindo as instruções em [Configurar o BGP do Cilium para nós híbridos](hybrid-nodes-cilium-bgp.md). 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](helm.md) para obter mais informações.
+ O eksctl instalado em seu ambiente de linha de comando. Consulte as [instruções de instalação do eksctl](install-kubectl.md#eksctl-install-update) para obter mais informações.
### Procedimento
1. 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
```
1. 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
```
1. 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
```
1. 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
```
1. 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](hybrid-nodes-webhooks.md#hybrid-nodes-mixed-lbc).
+ 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
```
1. 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
```
1. Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. 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
```
1. Aplique a configuração do Ingress ao seu cluster.
```
kubectl apply -f my-ingress-alb.yaml
```
1. 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 `-..elb.amazonaws.com`.
```
kubectl get ingress my-ingress
```
```
NAME CLASS HOSTS ADDRESS PORTS AGE
my-ingress alb * my-ingress-alb-..elb.amazonaws.com 80 23m
```
1. Acesse o serviço usando o endereço do ALB.
```
curl -s http//my-ingress-alb-..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](https://gateway-api.sigs.k8s.io/) 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](https://docs.cilium.io/en/stable/network/servicemesh/ingress/) e [Gateway do Cilium](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/) 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ão1 |
| Rede do host | Sim | Sim |
| Balanceador de carga compartilhado | Sim | Sim |
| Balanceador de carga dedicado | Sim | Número2 |
| Políticas de rede | Sim | Sim |
| Protocolos | Camada 7 (HTTP(S), gRPC) | Camada 7 (HTTP(S), gRPC)3 |
| 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 |
1 O suporte do Gateway do Cilium para serviços NodePort está planejado para a versão 1.18.x do Cilium ([\$127273](https://github.com/cilium/cilium/pull/27273))
2 Suporte do Gateway do Cilium para balanceadores de carga dedicados ([\$125567](https://github.com/cilium/cilium/issues/25567))
3 Suporte do Gateway do Cilium para TCP/UDP ([\$121929](https://github.com/cilium/cilium/issues/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](#hybrid-nodes-ingress-cilium-host-network) para obter mais informações.
### Pré-requisitos
1. O Helm foi instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md).
1. Cilium instalado seguindo as instruções em [Configurar a CNI para nós híbridos](hybrid-nodes-cni.md).
### Procedimento
1. 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
```
1. 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
```
1. 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
```
1. 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](#hybrid-nodes-ingress-cilium-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.](https://gateway-api.sigs.k8s.io/reference/spec/#gateway)
```
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:
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](https://gateway-api.sigs.k8s.io/api-types/httproute/HTTPRoute) e [GRPCRoute](https://gateway-api.sigs.k8s.io/api-types/grpcroute/GRPCRoute) para ver a lista de campos disponíveis.
+ Veja os exemplos na seção [Implantar o Gateway do Cilium](#hybrid-nodes-ingress-cilium-gateway-deploy) abaixo e os exemplos na [documentação do Cilium](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#examples) para saber como usar e configurar esses recursos.
## Implantar o Gateway do Cilium
1. Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. 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
```
1. 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
```
1. Aplique o recurso do Gateway ao seu cluster.
```
kubectl apply -f my-gateway.yaml
```
1. 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 80:30912/TCP 24s
```
1. Continue para [Tipo de serviço LoadBalancer](#hybrid-nodes-ingress-cilium-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](#hybrid-nodes-ingress-cilium-nodeport) ou [Rede do host](#hybrid-nodes-ingress-cilium-host-network) 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](https://github.com/cilium/cilium/blob/v1.17.6/install/kubernetes/cilium/values.yaml#L887) 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](#hybrid-nodes-ingress-cilium-host-network) 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](https://github.com/cilium/cilium/blob/main/install/kubernetes/cilium/templates/cilium-ingress-service.yaml).
### Pré-requisitos
1. O Helm foi instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md).
1. Cilium instalado seguindo as instruções em [Configurar a CNI para nós híbridos](hybrid-nodes-cni.md).
### Procedimento
1. 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
```
1. 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
```
1. 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](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#supported-ingress-annotations) 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](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#ingress-path-types-and-precedence) e [Exemplos de tipos de caminhos](https://docs.cilium.io/en/stable/network/servicemesh/path-types/) na documentação do Cilium e os exemplos na seção [Implementar o Ingress do Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy) 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
1. Crie uma aplicação de exemplo. O exemplo abaixo usa a aplicação de microsserviços de amostra [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. 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
```
1. 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
```
1. Aplique o recurso do Ingress ao seu cluster.
```
kubectl apply -f my-ingress.yaml
```
1. 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 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 80:32088/TCP,443:30332/TCP 25s
```
1. Continue para [Tipo de serviço LoadBalancer](#hybrid-nodes-ingress-cilium-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](#hybrid-nodes-ingress-cilium-nodeport) ou [Rede do host](#hybrid-nodes-ingress-cilium-host-network) 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](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/) e a [documentação do Gateway do Kubernetes](https://gateway-api.sigs.k8s.io/implementations/) 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](https://docs.cilium.io/en/stable/network/lb-ipam/) (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](#hybrid-nodes-ingress-cilium-ingress-install) ou [Instale o Gateway do Cilium](#hybrid-nodes-ingress-cilium-gateway-install).
+ Recursos do Ingress ou Gateway do Cilium com a aplicação de amostra implantada seguindo as instruções em [Implementar o Ingress do Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy) ou [Implantar o Gateway do Cilium](#hybrid-nodes-ingress-cilium-gateway-deploy).
+ O ambiente de gerenciamento BGP do Cilium é habilitado seguindo as instruções em [Configurar o BGP do Cilium para nós híbridos](hybrid-nodes-cilium-bgp.md). 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
1. 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"}}
}'
```
1. 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](https://docs.cilium.io/en/stable/network/lb-ipam/) 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"
```
1. Aplique o recurso `CiliumLoadBalancerIPPool` ao seu cluster.
```
kubectl apply -f cilium-lbip-pool-ingress.yaml
```
1. 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
```
1. 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"
```
1. Aplique o recurso `CiliumBGPAdvertisement` ao seu cluster.
```
kubectl apply -f cilium-bgp-advertisement-ingress.yaml
```
1. 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 ([\$127273](https://github.com/cilium/cilium/pull/27273))
### Pré-requisitos
+ O Ingress do Cilium foi instalado seguindo as instruções em [Instale o Ingress do Cilium](#hybrid-nodes-ingress-cilium-ingress-install).
+ Recursos do Ingress do Cilium com aplicação de amostra implantada seguindo as instruções em [Implementar o Ingress do Cilium](#hybrid-nodes-ingress-cilium-ingress-deploy).
### Procedimento
1. 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](#hybrid-nodes-ingress-cilium-ingress-deploy).
```
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
```
1. 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 80:32353/TCP,443:30253/TCP 27m
```
1. 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 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. 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](#hybrid-nodes-ingress-cilium-ingress-install) ou [Instale o Gateway do Cilium](#hybrid-nodes-ingress-cilium-gateway-install).
### Procedimento
#### Gateway
1. 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
```
1. 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](#hybrid-nodes-ingress-cilium-gateway-deploy). 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](https://docs.cilium.io/en/stable/network/servicemesh/gateway-api/gateway-api/#bind-to-privileged-port) 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]}
```
1. 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 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. 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 ([\$134028](https://github.com/cilium/cilium/issues/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](https://docs.cilium.io/en/stable/network/servicemesh/ingress/#bind-to-privileged-port) para obter instruções.
1. 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
```
1. 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](#hybrid-nodes-ingress-cilium-ingress-deploy).
```
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]}
```
1. 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 23h v1.32.3-eks-473151a 10.80.146.150 Ubuntu 22.04.5 LTS 5.15.0-142-generic containerd://1.7.27
mi-082f73826a163626e Ready 23h v1.32.3-eks-473151a 10.80.146.32 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-09183e8a3d755abf6 Ready 23h v1.32.3-eks-473151a 10.80.146.33 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0d78d815980ed202d Ready 23h v1.32.3-eks-473151a 10.80.146.97 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
mi-0daa253999fe92daa Ready 23h v1.32.3-eks-473151a 10.80.146.100 Ubuntu 22.04.4 LTS 5.15.0-142-generic containerd://1.7.27
```
1. 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"
}
```