Utilizar a política de rede calico para proteger o tráfego de pods

Artigo
05/01/2024

Aplica-se a: AKS no Azure Stack HCI 22H2, AKS no Windows Server

Utilize este guia passo a passo para verificar e experimentar a conectividade de pod a pod básica e para utilizar políticas de rede Calico num cluster num AKS ativado pela implementação do Azure Arc. Este artigo descreve como criar pods de cliente e servidor nos nós do Linux e do Windows, verificar a conectividade entre os pods e, em seguida, aplicar uma política de rede básica para isolar o tráfego de pods no AKS Arc.

Pré-requisitos

Para implementar o AKS Arc, siga os passos para configurar um anfitrião do AKS.

Para utilizar este guia, precisa de:

Um cluster de cargas de trabalho do AKS.
Pelo menos um nó de trabalho do Windows implementado no cluster.
Pelo menos um nó de trabalho do Linux implementado no cluster.
O plug-in de rede calico tem de estar ativado ao criar o cluster de cargas de trabalho. Se este plug-in não tiver sido ativado, consulte para obter New-AksHciCluster instruções.

Create pods em nós do Linux

Primeiro, crie um pod de cliente, busybox e pod do servidor, nginx, nos nós do Linux.

Create um ficheiro YAML chamado policy-demo-linux.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: calico-demo

---

apiVersion: v1
kind: Pod
metadata:
  labels:
    app: busybox
  name: busybox
  namespace: calico-demo
spec:
  containers:
  - args:
    - /bin/sh
    - -c
    - sleep 360000
    image: busybox:1.28
    imagePullPolicy: Always
    name: busybox
  nodeSelector:
    beta.kubernetes.io/os: linux

---

apiVersion: v1
kind: Pod
metadata:
  labels:
    app: nginx
  name: nginx
  namespace: calico-demo
spec:
  containers:
  - name: nginx
    image: nginx:1.8
    ports:
    - containerPort: 80
  nodeSelector:
    beta.kubernetes.io/os: linux

Aplicar o ficheiro policy-demo-linux.yaml ao cluster do Kubernetes

Abra uma janela do PowerShell e carregue as credenciais do cluster de destino com o Get-AksHciCredential comando .

Em seguida, utilize kubectl para aplicar a policy-demo-linux.yaml configuração, da seguinte forma:

kubectl apply -f policy-demo-linux.yaml

Create pods em nós do Windows

Create um pod de cliente pwsh e um carregador de pods de servidor nos nós do Windows.

Nota

O manifesto dos pods utiliza imagens com base em mcr.microsoft.com/windows/servercore:1809. Se estiver a utilizar uma versão mais recente do Windows Server, atualize os manifestos para utilizar uma imagem Server Core que corresponda à sua versão do Windows Server.

Create policy-demo-windows.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pwsh
  namespace: calico-demo
  labels:
    app: pwsh
spec:
  containers:
  - name: pwsh
    image: mcr.microsoft.com/windows/servercore:1809
    args:
    - powershell.exe
    - -Command
    - "Start-Sleep 360000"
    imagePullPolicy: IfNotPresent
  nodeSelector:
    kubernetes.io/os: windows
---
apiVersion: v1
kind: Pod
metadata:
  name: porter
  namespace: calico-demo
  labels:
    app: porter
spec:
  containers:
  - name: porter
    image: calico/porter:1809
    ports:
    - containerPort: 80
    env:
    - name: SERVE_PORT_80
      value: This is a Calico for Windows demo.
    imagePullPolicy: IfNotPresent
  nodeSelector:
    kubernetes.io/os: windows

Aplicar o ficheiro policy-demo-windows.yaml ao cluster do Kubernetes

Abra uma janela do PowerShell e carregue as credenciais do cluster de destino com o Get-AksHciCredential comando .

Em seguida, utilize kubectl para aplicar a policy-demo-windows.yaml configuração:

kubectl apply -f policy-demo-windows.yaml

Verifique se os quatro pods estão criados e em execução

Nota

Consoante a velocidade de transferência da rede, poderá demorar algum tempo a iniciar os pods do Windows.

Abra uma janela do PowerShell e carregue as credenciais do cluster de destino com o Get-AksHciCredential comando .

Em seguida, utilize kubectl para listar os pods no calico-demo espaço de nomes:

kubectl get pods --namespace calico-demo

Deverá ver um resultado semelhante ao seguinte exemplo:

NAME      READY   STATUS              RESTARTS   AGE
busybox   1/1     Running             0          4m14s
nginx     1/1     Running             0          4m14s
porter    0/1     ContainerCreating   0          74s
pwsh      0/1     ContainerCreating   0          2m9s

Repita o comando de poucos em poucos minutos até a saída mostrar os quatro pods no estado Em execução.

NAME      READY   STATUS    RESTARTS   AGE
busybox   1/1     Running   0          7m24s
nginx     1/1     Running   0          7m24s
porter    1/1     Running   0          4m24s
pwsh      1/1     Running   0          5m19s

Verificar a conectividade entre pods nos nós do Linux e do Windows

Agora que os pods do cliente e do servidor estão em execução nos nós do Linux e do Windows, verifique se os pods de cliente nos nós do Linux podem aceder aos pods do servidor nos nós do Windows.

Abra uma janela do PowerShell e carregue as credenciais do cluster de destino com o Get-AksHciCredential comando .

Utilize kubectl para determinar o endereço IP do pod porter:

kubectl get pod porter --namespace calico-demo -o 'jsonpath={.status.podIP}'

Inicie sessão no pod busybox e tente aceder ao pod porter na porta 80. Substitua a etiqueta "<porter_ip>" pelo endereço IP devolvido do comando anterior.
```
kubectl exec --namespace calico-demo busybox -- nc -vz <porter_ip> 80
```
Também pode combinar ambos os passos acima:
```
kubectl exec --namespace calico-demo busybox -- nc -vz $(kubectl get pod porter --namespace calico-demo -o 'jsonpath={.status.podIP}') 80
```
Se a ligação do pod busybox para o pod porter for bem-sucedida, obterá um resultado semelhante ao seguinte exemplo:
```
192.168.40.166 (192.168.40.166:80) open
```
Nota

Os endereços IP devolvidos podem variar consoante a configuração do seu ambiente.

Verifique se o pod pwsh consegue aceder ao pod nginx :

kubectl exec --namespace calico-demo pwsh -- powershell Invoke-WebRequest -Uri http://$(kubectl get po nginx -n calico-demo -o 'jsonpath={.status.podIP}') -UseBasicParsing -TimeoutSec 5

Se a ligação for bem-sucedida, verá um resultado semelhante a:

StatusCode        : 200
StatusDescription : OK
Content           : <!DOCTYPE html>
                    <html>
                    <head>
                    <title>Welcome to nginx!</title>
                    <style>
                        body {
                            width: 35em;
                            margin: 0 auto;
                            font-family: Tahoma, Verdana, Arial, sans-serif;
                        }
                    </style>
                    <...

Verifique se o pod pwsh consegue aceder ao pod porter :

kubectl exec --namespace calico-demo pwsh -- powershell Invoke-WebRequest -Uri http://$(kubectl get po porter -n calico-demo -o 'jsonpath={.status.podIP}') -UseBasicParsing -TimeoutSec 5

Se for bem-sucedido, verá um resultado semelhante ao seguinte exemplo:

StatusCode        : 200
StatusDescription : OK
Content           : This is a Calico for Windows demo.
RawContent        : HTTP/1.1 200 OK
                    Content-Length: 49
                    Content-Type: text/plain; charset=utf-8
                    Date: Fri, 21 Aug 2020 22:45:46 GMT

                    This is a Calico for Windows demo.
Forms             :
Headers           : {[Content-Length, 49], [Content-Type, text/plain;
                    charset=utf-8], [Date, Fri, 21 Aug 2020 22:45:46 GMT]}
Images            : {}
InputFields       : {}
Links             : {}
ParsedHtml        :
RawContentLength  : 49

Verificou agora que a comunicação é possível entre todos os pods na aplicação.

Aplicar a política ao pod de cliente do Windows

Numa implementação do mundo real, quer certificar-se de que apenas os pods que devem comunicar entre si podem fazê-lo. Para tal, aplique uma política de rede básica que permita que apenas o pod busybox chegue ao pod porter .

Create o ficheiro network-policy.yaml

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-busybox
  namespace: calico-demo
spec:
  podSelector:
    matchLabels:
      app: porter
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: busybox
    ports:
    - protocol: TCP
      port: 80

Aplicar o ficheiro network-policy.yaml

Abra uma janela do PowerShell.
Carregue as credenciais do cluster de destino com o Get-AksHciCredential comando .
Utilize kubectl para aplicar o ficheiro network-policy.yaml:
```
kubectl apply -f network-policy.yaml
```

Verifique se a política está em vigor

Com a política implementada, o pod busybox ainda deverá conseguir aceder ao pod porter . Conforme indicado anteriormente, pode combinar os passos na linha de comandos:

kubectl exec --namespace calico-demo busybox -- nc -vz $(kubectl get po porter -n calico-demo -o 'jsonpath={.status.podIP}') 80

No entanto, o pod pwsh não conseguirá alcançar o pod porter :

kubectl exec --namespace calico-demo pwsh -- powershell Invoke-WebRequest -Uri http://$(kubectl get po porter -n calico-demo -o 'jsonpath={.status.podIP}') -UseBasicParsing -TimeoutSec 5

O pedido excede o limite de tempo com uma mensagem como esta:

Invoke-WebRequest : The operation has timed out.
At line:1 char:1
+ Invoke-WebRequest -Uri http://192.168.40.166 -UseBasicParsing -Timeout ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (System.Net.HttpWebRequest:Htt
pWebRequest) [Invoke-WebRequest], WebException
    + FullyQualifiedErrorId : WebCmdletWebResponseException,Microsoft.PowerShell.Commands.InvokeWebRequestCommand
command terminated with exit code 1

Nesta demonstração, configurámos pods nos nós do Linux e do Windows, verificámos a conectividade básica do pod e tentámos uma política de rede básica para isolar o tráfego pod a pod.

Como passo final, pode limpar todos os recursos de demonstração:

kubectl delete namespace calico-demo

Passos seguintes

Neste artigo, aprendeu a proteger o tráfego entre pods através de políticas de rede. Em seguida, pode:

Partilhar via

Utilizar a política de rede calico para proteger o tráfego de pods

Pré-requisitos

Create pods em nós do Linux

Create um ficheiro YAML chamado policy-demo-linux.yaml

Aplicar o ficheiro policy-demo-linux.yaml ao cluster do Kubernetes

Create pods em nós do Windows

Create policy-demo-windows.yaml

Aplicar o ficheiro policy-demo-windows.yaml ao cluster do Kubernetes

Verifique se os quatro pods estão criados e em execução

Verificar a conectividade entre pods nos nós do Linux e do Windows

Aplicar a política ao pod de cliente do Windows

Create o ficheiro network-policy.yaml

Aplicar o ficheiro network-policy.yaml

Verifique se a política está em vigor

Passos seguintes

Comentários

Comentários

Recursos adicionais