Use a política de rede Calico para proteger o tráfego de pods

Artigo
06/28/2024

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

Use este guia de instruções para verificar e experimentar a conectividade básica de pod-to-pod e para usar as políticas de rede do Calico em um cluster em um AKS habilitado pela implantação do Arc. Este artigo descreve como criar pods de cliente e servidor em nós Linux e 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 implantar o AKS Arc, siga as etapas para configurar um host AKS.

Para usar este guia, você precisa:

Um cluster de carga de trabalho AKS.
Pelo menos um nó de trabalho do Windows implantado no cluster.
Pelo menos um nó de trabalho Linux implantado no cluster.
O plug-in de rede Calico deve ser habilitado ao criar o cluster de carga de trabalho. Se este plug-in não estiver ativado, consulte New-AksHciCluster para obter instruções.

Criar pods em nós Linux

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

Crie um arquivo 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

Aplique o arquivo policy-demo-linux.yaml ao cluster do Kubernetes

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

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

kubectl apply -f policy-demo-linux.yaml

Criar pods em nós do Windows

Crie um pod pwsh de cliente e um pod porter de servidor nos nós do Windows.

Nota

Os manifestos pod usam imagens baseadas em mcr.microsoft.com/windows/servercore:1809. Se você estiver usando uma versão mais recente do Windows Server, atualize os manifestos para usar uma imagem Server Core que corresponda à sua versão do Windows Server.

Crie o 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

Aplique o arquivo policy-demo-windows.yaml ao cluster do Kubernetes

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

Em seguida, use 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

Dependendo da velocidade de download da rede, pode levar tempo para iniciar os pods do Windows.

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

Em seguida, use kubectl para listar os pods no calico-demo namespace:

kubectl get pods --namespace calico-demo

Você deve ver uma saída semelhante ao exemplo a seguir:

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 a cada poucos minutos até que a saída mostre todos os quatro pods no estado Running.

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

Verifique a conectividade entre pods em nós Linux e Windows

Agora que os pods de cliente e servidor estão sendo executados em nós Linux e Windows, verifique se os pods de cliente em nós Linux podem alcançar pods de servidor em nós Windows.

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

Use kubectl para determinar o endereço IP do pod porteiro:

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

Entre no pod busybox e tente chegar ao pod porteiro na porta 80. Substitua a tag '<porter_ip>' pelo endereço IP retornado do comando anterior:
```
kubectl exec --namespace calico-demo busybox -- nc -vz <porter_ip> 80
```
Você também pode combinar as duas etapas anteriores:
```
kubectl exec --namespace calico-demo busybox -- nc -vz $(kubectl get pod porter --namespace calico-demo -o 'jsonpath={.status.podIP}') 80
```
Se a conexão do pod busybox com o pod de porter for bem-sucedida, você obterá uma saída semelhante ao exemplo a seguir:
```
192.168.40.166 (192.168.40.166:80) open
```
Nota

Os endereços IP retornados podem variar dependendo da configuração do seu ambiente.

Verifique se o pod pwsh pode alcançar o 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 conexão for bem-sucedida, você verá uma saída 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 pode alcançar o pod porteiro :

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 isso for bem-sucedido, você verá uma saída semelhante ao exemplo a seguir:

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

Agora você verificou que a comunicação é possível entre todos os pods no aplicativo.

Aplicar a política ao pod do cliente Windows

Em uma implantação no mundo real, você quer ter certeza de que apenas pods que devem se comunicar entre si tenham permissão para fazê-lo. Para conseguir isso, você aplica uma política de rede básica que permite que apenas o pod busybox alcance o pod porter.

Criar o arquivo 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 arquivo network-policy.yaml

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

Verifique se a política está em vigor

Com a política em vigor, o pod busybox ainda deve ser capaz de alcançar o pod porteiro . Como observado anteriormente, você pode combinar as etapas na linha de comando:

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 pode alcançar o pod porteiro:

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 tempo limite da solicitação é exibido com uma mensagem semelhante a 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, configuramos pods em nós Linux e Windows, verificamos a conectividade básica do pod e tentamos uma política de rede básica para isolar o tráfego de pod para pod.

Como etapa final, você pode limpar todos os recursos de demonstração:

kubectl delete namespace calico-demo

Próximos passos

Neste artigo, você aprendeu como proteger o tráfego entre pods usando diretivas de rede. Em seguida, você pode:

Partilhar via

Use a política de rede Calico para proteger o tráfego de pods

Pré-requisitos

Criar pods em nós Linux

Crie um arquivo YAML chamado policy-demo-linux.yaml

Aplique o arquivo policy-demo-linux.yaml ao cluster do Kubernetes

Criar pods em nós do Windows

Crie o policy-demo-windows.yaml

Aplique o arquivo policy-demo-windows.yaml ao cluster do Kubernetes

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

Verifique a conectividade entre pods em nós Linux e Windows

Aplicar a política ao pod do cliente Windows

Criar o arquivo network-policy.yaml

Aplicar o arquivo network-policy.yaml

Verifique se a política está em vigor

Próximos passos

Comentários

Comentários

Recursos adicionais