**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 políticas de rede do Kubernetes para nós híbridos
A AWS oferece suporte para políticas de rede do Kubernetes (camada 3/camada 4) para tráfego de entrada e saída de pod ao usar o Cilium como a CNI com o EKS Hybrid Nodes. Se você estiver executando clusters EKS com nós na Nuvem AWS, a AWS oferece suporte às [políticas de rede CNI da Amazon VPC para Kubernetes](cni-network-policy.md).
Este tópico aborda como configurar as políticas de rede do Cilium e do Kubernetes com o EKS Hybrid Nodes. Para obter informações detalhadas sobre as políticas de rede do Kubernetes, consulte Políticas de rede do [Kubernetes na documentação do Kubernetes.](https://kubernetes.io/docs/concepts/services-networking/network-policies/)
## Configure as políticas de rede
### Considerações
+ A AWS oferece suporte para as políticas de rede upstream do Kubernetes e a especificação para entrada e saída de pods. No momento, a AWS não oferce suporte para `CiliumNetworkPolicy` ou `CiliumClusterwideNetworkPolicy`.
+ O valor `policyEnforcementMode` do Helm pode ser usado para controlar o comportamento padrão de aplicação da política do Cilium. O comportamento padrão permite todo o tráfego de entrada e saída. Quando um endpoint é selecionado por uma política de rede, ele passa para um estado de negação padrão, em que somente o tráfego explicitamente permitido é permitido. Consulte a documentação do Cilium para obter mais informações sobre o modo de [política padrão e os modos de [aplicação de políticas](https://docs.cilium.io/en/stable/security/policy/intro/#policy-enforcement-modes).](https://docs.cilium.io/en/stable/security/policy/intro/#policy-mode-default)
+ Caso esteja mudando `policyEnforcementMode` para uma instalação existente do Cilium, você deverá reiniciar o DaemonSet do atendente do Cilium para aplicar o novo modo de imposição de políticas.
+ Use `namespaceSelector` e `podSelector` para permitir ou negar tráfego de/para namespaces e pods com rótulos correspondentes. O `namespaceSelector` e `podSelector` podem ser usados com `matchLabels` ou `matchExpressions` para selecionar namespaces e pods com base em seus rótulos.
+ Use `ingress.ports` e `egress.ports` para permitir ou negar tráfego de/para portas e protocolos.
+ O campo `ipBlock` não pode ser usado para permitir ou negar seletivamente o tráfego de/para endereços IP do pod ([\$19209](https://github.com/cilium/cilium/issues/9209)). O uso de seletores `ipBlock` para IPs de nós é um atributo beta do Cilium e não é compatível com a AWS.
+ Consulte o [recurso NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) na documentação do Kubernetes para obter informações sobre os campos disponíveis para as políticas de rede do Kubernetes.
### Pré-requisitos
+ Cilium instalado seguindo as instruções em [Configurar a CNI para nós híbridos](hybrid-nodes-cni.md).
+ O Helm foi instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md).
### Procedimento
O procedimento a seguir configura políticas de rede para uma aplicação de microsserviços de exemplo, de forma que os componentes só possam se comunicar com outros componentes necessários para o funcionamento da aplicação. O procedimento usa a aplicação de microsserviços de amostra [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
A aplicação Bookinfo consiste em quatro microsserviços separados com os seguintes relacionamentos:
+ **productpage**. O microsserviço productpage chama os microsserviços de detalhes e resenhas para preencher a página.
+ **detalhes**. O microsserviço de detalhes contém informações sobre o livro.
+ **análises**. O microsserviço de resenhas contém resenhas de livros. Também chama o microsserviço de classificações.
+ **classificações**. O microsserviço de classificações contém informações de classificação de livros que acompanham uma resenha de livro.
1. Crie as aplicações de exemplo.
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Confirme se a aplicação estiver sendo executado com êxito e anote o endereço IP do pod do microsserviço productpage. Você usará esse endereço IP do pod para fazer uma consulta sobre cada microsserviço nas etapas subsequentes.
```
kubectl get pods -o wide
```
```
NAME READY STATUS RESTARTS AGE IP NODE
details-v1-766844796b-9wff2 1/1 Running 0 7s 10.86.3.7 mi-0daa253999fe92daa
productpage-v1-54bb874995-lwfgg 1/1 Running 0 7s 10.86.2.193 mi-082f73826a163626e
ratings-v1-5dc79b6bcd-59njm 1/1 Running 0 7s 10.86.2.232 mi-082f73826a163626e
reviews-v1-598b896c9d-p2289 1/1 Running 0 7s 10.86.2.47 mi-026d6a261e355fba7
reviews-v2-556d6457d-djktc 1/1 Running 0 7s 10.86.3.58 mi-0daa253999fe92daa
reviews-v3-564544b4d6-g8hh4 1/1 Running 0 7s 10.86.2.69 mi-09183e8a3d755abf6
```
1. Crie um pod que será usado para testar as políticas de rede. Observe que o pod é criado no namespace `default` com o rótulo `access: true`.
```
kubectl run curl-pod --image=curlimages/curl -i --tty --labels=access=true --namespace=default --overrides='{"spec": { "nodeSelector": {"eks.amazonaws.com/compute-type": "hybrid"}}}' -- /bin/sh
```
1. Teste o acesso ao microsserviço productpage. No exemplo abaixo, usamos o endereço IP do pod productpage (`10.86.2.193`) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
```
```
Simple Bookstore App
```
1. Você pode sair do pod test curl digitando `exit` e reconectar-se ao pod executando o seguinte comando.
```
kubectl attach curl-pod -c curl-pod -i -t
```
1. Para demonstrar os efeitos das políticas de rede nas etapas a seguir, primeiro criamos uma política de rede que nega todo o tráfego dos microsserviços da BookInfo. Crie um arquivo chamado `network-policy-deny-bookinfo.yaml` que defina a política de negação de rede.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-bookinfo
namespace: default
spec:
podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "details", "reviews", "ratings"]
policyTypes:
- Ingress
- Egress
```
1. Aplique a política de negação de rede ao seu cluster.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
1. Teste o acesso à aplicação BookInfo. No exemplo abaixo, usamos o endereço IP do pod productpage (`10.86.2.193`) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.
```
curl http://10.86.2.193:9080/productpage --max-time 10
```
```
curl: (28) Connection timed out after 10001 milliseconds
```
1. Crie um arquivo chamado `network-policy-productpage.yaml` que defina a política de rede de productpage. A política estabelece as seguintes regras:
+ permite o tráfego de entrada de pods com o rótulo `access: true` (o pod curl criado na etapa anterior)
+ permite o tráfego TCP de saída na porta `9080` para os microsserviços de detalhes, avaliações e classificações
+ permite o tráfego TCP/UDP de saída na porta `53` para o CoreDNS, que é executado no namespace `kube-system`
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: productpage-policy
namespace: default
spec:
podSelector:
matchLabels:
app: productpage
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
access: "true"
egress:
- to:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["details", "reviews", "ratings"]
ports:
- port: 9080
protocol: TCP
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Aplique a política de rede do productpage ao seu cluster.
```
kubectl apply -f network-policy-productpage.yaml
```
1. Conecte-se ao pod curl e teste o acesso à aplicação Bookinfo. O acesso ao microsserviço productpage agora é permitido, mas os outros microsserviços ainda estão negados porque ainda estão sujeitos à política de rede de negação. Nos exemplos abaixo, usamos o endereço IP do pod de productpage (`10.86.2.193`) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.
```
kubectl attach curl-pod -c curl-pod -i -t
```
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
Simple Bookstore App
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1
{"error": "Sorry, product details are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
{"error": "Sorry, product reviews are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
{"error": "Sorry, product ratings are currently unavailable for this book."}
```
1. Crie um arquivo chamado `network-policy-details.yaml` que defina os detalhes da política de rede. A política permite somente o tráfego de entrada do microsserviço productpage.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: details-policy
namespace: default
spec:
podSelector:
matchLabels:
app: details
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
```
1. Crie um arquivo chamado `network-policy-reviews.yaml` que defina a política de rede de avaliações. A política permite somente o tráfego de entrada do microsserviço productpage e somente o tráfego de saída para o microsserviço de classificações e o CoreDNS.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: reviews-policy
namespace: default
spec:
podSelector:
matchLabels:
app: reviews
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
egress:
- to:
- podSelector:
matchLabels:
app: ratings
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Crie um arquivo chamado `network-policy-ratings.yaml` que defina a política de rede de classificações. A política permite somente o tráfego de entrada dos microsserviços productpage e avaliações.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: ratings-policy
namespace: default
spec:
podSelector:
matchLabels:
app: ratings
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "reviews"]
```
1. Aplique as políticas de rede de detalhes, avaliações e classificações ao seu cluster.
```
kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml
```
1. Conecte-se ao pod curl e teste o acesso à aplicação Bookinfo. Nos exemplos abaixo, usamos o endereço IP do pod de productpage (`10.86.2.193`) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.
```
kubectl attach curl-pod -c curl-pod -i -t
```
Teste o microsserviço de detalhes.
```
curl -s http://10.86.2.193:9080/api/v1/products/1
```
```
{"id": 1, "author": "William Shakespeare", "year": 1595, "type": "paperback", "pages": 200, "publisher": "PublisherA", "language": "English", "ISBN-10": "1234567890", "ISBN-13": "123-1234567890"}
```
Teste o microsserviço de avaliações.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
```
```
{"id": "1", "podname": "reviews-v1-598b896c9d-p2289", "clustername": "null", "reviews": [{"reviewer": "Reviewer1", "text": "An extremely entertaining play by Shakespeare. The slapstick humour is refreshing!"}, {"reviewer": "Reviewer2", "text": "Absolutely fun and entertaining. The play lacks thematic depth when compared to other plays by Shakespeare."}]}
```
Teste o microsserviço de classificações.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
```
```
{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}
```
1. Limpe os recursos que você criou nesse processo.
```
kubectl delete -f network-policy-deny-bookinfo.yaml
kubectl delete -f network-policy-productpage.yaml
kubectl delete -f network-policy-details.yaml
kubectl delete -f network-policy-reviews.yaml
kubectl delete -f network-policy-ratings.yaml
kubectl delete -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
kubectl delete pod curl-pod
```