Dela via

Använda Calico-nätverksprincip för att skydda poddtrafik

  • Artikel

Gäller för: AKS på Azure Stack HCI 22H2, AKS på Windows Server

Använd den här instruktionsguiden för att verifiera och prova grundläggande pod-till-pod-anslutning och för att använda Calico-nätverksprinciper i ett kluster i en AKS som aktiveras av Arc-distributionen. Den här artikeln beskriver hur du skapar klient- och serverpoddar på Linux- och Windows-noder, verifierar anslutningen mellan poddarna och sedan tillämpar en grundläggande nätverksprincip för att isolera poddtrafik i AKS Arc.

Förutsättningar

Om du vill distribuera AKS Arc följer du stegen för att konfigurera en AKS-värd.

Om du vill använda den här guiden behöver du:

  • Ett AKS-arbetsbelastningskluster.
  • Minst en Windows-arbetsnod som distribueras i klustret.
  • Minst en Linux-arbetsnod som distribuerats i klustret.
  • Calico-nätverksinsticksprogrammet måste vara aktiverat när du skapar arbetsbelastningsklustret. Om plugin-programmet inte har aktiverats kan du läsa New-AksHciCluster mer i mer information.

Skapa poddar på Linux-noder

Skapa först en klientpodd, busybox och serverpodd, nginx, på Linux-noderna.

Skapa en YAML-fil med namnet 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

Tillämpa filen policy-demo-linux.yaml på Kubernetes-klustret

Öppna ett PowerShell-fönster och läs in autentiseringsuppgifterna för målklustret med hjälp av Get-AksHciCredential kommandot .

kubectl Använd sedan för att tillämpa konfigurationen policy-demo-linux.yaml på följande sätt:

kubectl apply -f policy-demo-linux.yaml

Skapa poddar på Windows-noder

Skapa en klientpodd pwsh och serverpodd porter på Windows-noderna.

Kommentar

Poddmanifesten använder bilder baserade på mcr.microsoft.com/windows/servercore:1809. Om du använder en nyare Windows Server-version uppdaterar du manifesten för att använda en Server Core-avbildning som matchar din Windows Server-version.

Skapa 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

Tillämpa filen policy-demo-windows.yaml på Kubernetes-klustret

Öppna ett PowerShell-fönster och läs in autentiseringsuppgifterna för målklustret med hjälp av Get-AksHciCredential kommandot .

kubectl Använd sedan för att tillämpa konfigurationenpolicy-demo-windows.yaml:

kubectl apply -f policy-demo-windows.yaml

Kontrollera att de fyra poddarna har skapats och körs

Kommentar

Beroende på nätverkets nedladdningshastighet kan det ta tid att starta Windows-poddarna.

Öppna ett PowerShell-fönster och läs in autentiseringsuppgifterna för målklustret med hjälp av Get-AksHciCredential kommandot .

kubectl Använd sedan för att lista poddarna i calico-demo namnområdet:

kubectl get pods --namespace calico-demo

Du bör se utdata som liknar följande exempel:

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

Upprepa kommandot med några minuters mellanrum tills utdata visar alla fyra poddar i tillståndet Körs.

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

Kontrollera anslutningen mellan poddar på Linux- och Windows-noder

Nu när klient- och serverpoddarna körs på både Linux- och Windows-noder kontrollerar du att klientpoddar på Linux-noder kan nå serverpoddar på Windows-noder.

  1. Öppna ett PowerShell-fönster och läs in autentiseringsuppgifterna för målklustret med hjälp av Get-AksHciCredential kommandot .

  2. Använd kubectl för att fastställa PORTER-poddens IP-adress:

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

  3. Logga in på busybox-podden och försök nå porter-podden på port 80. Ersätt taggen "<porter_ip>" med IP-adressen som returnerades från föregående kommando:

    kubectl exec --namespace calico-demo busybox -- nc -vz <porter_ip> 80

    Du kan också kombinera båda föregående steg:

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

    Om anslutningen från busybox-podden till porter-podden lyckas får du utdata som liknar följande exempel:

    192.168.40.166 (192.168.40.166:80) open

    Kommentar

    De IP-adresser som returneras kan variera beroende på din miljökonfiguration.

  4. Kontrollera att pwsh-podden kan nå nginx-podden :

    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

    Om anslutningen lyckas ser du utdata som liknar:

    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>
                    <...

  5. Kontrollera att pwsh-podden kan nå porter-podden:

    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

    Om det lyckas visas utdata som liknar följande exempel:

    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

Nu har du kontrollerat att kommunikation är möjlig mellan alla poddar i programmet.

Tillämpa principen på Windows-klientpodden

I en verklig distribution vill du se till att endast poddar som ska kommunicera med varandra tillåts göra det. För att uppnå detta använder du en grundläggande nätverksprincip som endast tillåter att busybox-podden når porter-podden .

Skapa filen 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

Tillämpa filen network-policy.yaml

  1. Öppna ett PowerShell-fönster.

  2. Läs in autentiseringsuppgifterna för målklustret med kommandot Get-AksHciCredential .

  3. Använd kubectl för att tillämpa filen network-policy.yaml:

    kubectl apply -f network-policy.yaml

Kontrollera att principen gäller

När principen är på plats bör busybox-podden fortfarande kunna nå porter-podden . Som tidigare nämnts kan du kombinera stegen på kommandoraden:

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

Pwsh-podden kan dock inte nå porter-podden:

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

Begäran överskrider tidsgränsen med ett meddelande som liknar det här:

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

I den här demonstrationen konfigurerade vi poddar på Linux- och Windows-noder, verifierade grundläggande poddanslutning och provade en grundläggande nätverksprincip för att isolera podd-till-pod-trafik.

Som det sista steget kan du rensa alla demoresurser:

kubectl delete namespace calico-demo

Nästa steg

I den här artikeln har du lärt dig hur du skyddar trafik mellan poddar med hjälp av nätverksprinciper. Sedan kan du: