Zabezpieczanie ruchu między zasobnikami przy użyciu zasad sieciowych w uchwale AKS na Azure Stack HCI

Skorzystaj z tego przewodnika krok po kroku, aby zweryfikować i wypróbować podstawową łączność między zasobnikami oraz użyć zasad sieciowych firmy Calico w klastrze. W tym przewodniku dowiesz się, jak tworzyć zasobniki klienta i serwera w węzłach systemów Linux i Windows, weryfikować łączność między zasobnikami, a następnie stosować podstawowe zasady sieci w celu odizolować ruch zasobników.

Wymagania wstępne

Aby wdrożyć usługę AKS na Azure Stack HCI, wykonaj kroki instalowania usługi AKSna Azure Stack HCI .

Do korzystania z tego przewodnika potrzebne są:

  • Usługa AKS w klastrze Azure Stack HCI obciążenia.
  • Co najmniej jeden węzeł roboczy systemu Windows wdrożony w klastrze.
  • Co najmniej jeden węzeł roboczy systemu Linux wdrożony w klastrze.
  • Wtyczka sieciowa Calico jest włączona podczas tworzenia klastra obciążenia. Jeśli ta wtyczka nie została włączona, zobacz , New-AksHciCluster aby uzyskać instrukcje.

Tworzenie zasobników w węzłach systemu Linux

Najpierw utwórz zasobnik klienta, busybox i zasobnik serwera nginx w węzłach systemu Linux.

Utwórz plik YAML o nazwie 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

Stosowanie pliku policy-demo-linux.yaml do klastra Kubernetes

Otwórz okno programu PowerShell i załaduj poświadczenia dla klastra docelowego za pomocą Get-AksHciCredential polecenia .

Następnie użyj funkcji kubectl , aby zastosować policy-demo-linux.yaml konfigurację, jak pokazano poniżej:

kubectl apply -f policy-demo-linux.yaml

Tworzenie zasobników w węzłach okna

Utwórz zasobnik klienta pwsh i porter zasobnika serwera w węzłach systemu Windows.

Uwaga

Manifest zasobników używa obrazów opartych mcr.microsoft.com/windows/servercore:1809 na . Jeśli używasz najnowszej wersji systemu Windows Server, zaktualizuj manifesty, aby użyć obrazu Server Core, który odpowiada wersji systemu Windows Server.

Tworzenie pliku 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

Stosowanie pliku policy-demo-windows.yaml do klastra Kubernetes

Otwórz okno programu PowerShell i załaduj poświadczenia dla klastra docelowego za pomocą Get-AksHciCredential polecenia .

Następnie użyj , kubectl aby zastosować policy-demo-windows.yaml konfigurację:

kubectl apply -f policy-demo-windows.yaml

Sprawdź, czy cztery zasobniki zostały utworzone i uruchomione

Uwaga

W zależności od szybkości pobierania sieci uruchomienie zasobników systemu Windows może zająć trochę czasu.

Otwórz okno programu PowerShell i załaduj poświadczenia dla klastra docelowego za pomocą Get-AksHciCredential polecenia .

Następnie użyj elementu kubectl , aby wyświetlić listę zasobników w przestrzeni nazw calico-demo :

kubectl get pods --namespace calico-demo

Powinny zostać wyświetlone dane wyjściowe podobne do pokazanych poniżej:

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

Powtarzaj polecenie co kilka minut, aż dane wyjściowe będą wyświetlać wszystkie cztery zasobniki w stanie Uruchomione.

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

Sprawdzanie łączności między zasobnikami w węzłach systemu Linux i Windows

Teraz, gdy zasobniki klienta i serwera są uruchomione w węzłach systemów Linux i Windows, sprawdź, czy zasobniki klienta w węzłach systemu Linux mogą docierać do zasobników serwerów w węzłach systemu Windows.

  1. Otwórz okno programu PowerShell i załaduj poświadczenia dla klastra docelowego za pomocą Get-AksHciCredential polecenia .

  2. Użyj kubectl , aby określić adres IP zasobnika portera:

    kubectl get pod porter --namespace calico-demo -o 'jsonpath={.status.podIP}'
    
  3. Zaloguj się do zasobnika busybox i spróbuj dojść do zasobnika portiera na porcie 80. Zastąp tag "<porter_ip>" adresem IP zwróconym z poprzedniego polecenia.

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

    Możesz również połączyć oba powyższe kroki:

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

    Jeśli połączenie z zasobnika busybox do zasobnika portiera zakończy się pomyślnie, otrzymasz dane wyjściowe podobne do pokazanych poniżej:

    192.168.40.166 (192.168.40.166:80) open
    

    Uwaga

    Zwracane adresy IP będą się różnić w zależności od konfiguracji środowiska.

  4. Sprawdź, czy zasobnik pwsh może uzyskać do zasobnika 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
    

    Jeśli połączenie zakończy się pomyślnie, zobaczysz dane wyjściowe podobne do:

    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. Sprawdź, czy zasobnik pwsh może uzyskać do zasobnika portera:

    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
    

    Jeśli to się powiedzie, zobaczysz coś podobnego do przedstawionego poniżej:

    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
    
    

Wiesz już, że komunikacja między wszystkimi zasobnikami w aplikacji jest możliwa.

Stosowanie zasad do zasobnika klienta systemu Windows

W rzeczywistym wdrożeniu należy upewnić się, że dozwolone są tylko zasobniki, które mają komunikować się ze sobą.

Aby to osiągnąć, należy zastosować podstawowe zasady sieci, które zezwalają tylko zasobnikowi busybox na dotarcie do zasobnika portera.

Tworzenie pliku 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

Stosowanie pliku network-policy.yaml

  1. Otwórz okno programu PowerShell.

  2. Załaduj poświadczenia dla klastra docelowego za pomocą Get-AksHciCredential polecenia .

  3. Użyj kubectl , aby zastosować plik network-policy.yaml.

    kubectl apply -f network-policy.yaml
    

Sprawdzanie, czy zasady są w mocy

Gdy zasady są już dostępne, zasobnik busybox powinien nadal mieć możliwość dotarcia do zasobnika portera. Jak wspomniano wcześniej w tym temacie, można połączyć kroki w wierszu polecenia:

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

Jednak zasobnik pwsh nie będzie mógł uzyskać do zasobnika portera:

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

Żądanie jest wyświetlane z komunikatem, jak pokazano poniżej:

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

W tym pokazie skonfigurowaliśmy zasobniki w węzłach systemów Linux i Windows, zweryfikowaliśmy podstawową łączność zasobników i próbowaliśmy na podstawie podstawowych zasad sieciowych odizolować ruch między zasobnikami. W ostatnim kroku możesz wyczyścić wszystkie zasoby demonstracyjne:

kubectl delete namespace calico-demo

Następne kroki

W tym artykule opisano sposób zabezpieczania ruchu między zasobnikami przy użyciu zasad sieciowych. Następnie możesz: