Odnajdywanie kamer ONVIF za pomocą Akri

Akri to interfejs zasobów platformy Kubernetes, który umożliwia łatwe uwidocznienie heterogenicznych urządzeń liściowych (takich jak kamery IP i urządzenia USB) jako zasobów w klastrze Kubernetes i stale wykrywa węzły, które mają dostęp do tych urządzeń, aby zaplanować obciążenia na ich podstawie. Akri to projekt piaskownicy CNCF wykonany dla krawędzi, obsługujący dynamiczny wygląd i zaginięcie urządzeń liścia. Obecnie obsługuje protokoły OPC UA, ONVIF i udev, ale można również zaimplementować niestandardowe programy obsługi protokołów udostępniane przez szablon. Przeczytaj więcej na temat Akri tutaj.

W tym artykule opisano sposób odnajdywania kamer ONVIF połączonych z tą samą siecią co klaster AKS Edge Essentials. ONVIF jest otwartym standardem branżowym dla urządzeń zabezpieczeń IP, powszechnie używanych do nadzoru wideo. Przeczytaj więcej na temat profilów ONVIF tutaj. Ta demonstracja ułatwia rozpoczęcie korzystania z Akri do odnajdywania kamer IP za pośrednictwem protokołu ONVIF i używania ich za pośrednictwem brokera wideo, który umożliwia korzystanie z materiału z aparatu i wyświetlanie go w aplikacji internetowej.

Wymagania wstępne

• Wdrożenie pojedynczej maszyny lub pełne wdrożenie usługi AKS Edge Essentials uruchomione (jeśli używasz prawdziwej kamery IP ONVIF, musisz utworzyć pełne wdrożenie z przełącznikiem zewnętrznym).
• Usługa Akri działa tylko w systemie Linux: w tym ćwiczeniu użyj węzłów systemu Linux.
• Kamera IP ONVIF połączona z tą samą siecią co klaster przełącznika zewnętrznego lub wyśmiewane działanie kontenera ONVIF (kroki wdrażania w następujący sposób).

Uwaga

Ten przykładowy broker ONVIF obecnie nie obsługuje łączenia się z kamerami, które wymagają uwierzytelniania. Aby uruchomić tę demonstrację, wyłącz uwierzytelnianie w aparacie ONVIF.

Pozorowanie kontenera ONVIF

Jeśli nie masz kamery IP ONVIF, możesz użyć naszego pozornego kontenera ONVIF w tym ćwiczeniu. Makiety kontener działa zarówno na jednej maszynie, jak i w pełnym wdrożeniu.

1. (Opcjonalnie) Jeśli chcesz skonfigurować niestandardowy kanał wideo RTSP dla kontenera ONVIF, zapisz plik wideo mp4 (najlepiej, jeśli jakość to SD, a nie HD) i skopiuj plik z katalogu maszyny hosta do węzła systemu Linux przy użyciu następującego polecenia (pamiętaj, aby zastąpić katalog maszyny hosta i odpowiednią nazwę pliku wideo):

   Copy-AksEdgeNodeFile -FromFile C:\Users\WinIotUser\Downloads\sample.mp4 -toFile /home/aksedge-user/sample.mp4 -PushFile
   

2. Otwórz pusty plik YAML i skopiuj/wklej następującą zawartość. Pamiętaj, aby zastąpić wartość po /mnt/ nazwie pliku wideo w obszarze MP4FILE. Zapisz plik jako onvif-mock.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: onvif-camera-mocking
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: onvif-camera-mocking
     strategy:
       type: RollingUpdate
       rollingUpdate:
         maxSurge: 1
         maxUnavailable: 1
     minReadySeconds: 5    
     template:
       metadata:
         labels:
           app: onvif-camera-mocking
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: azure-vote-front
           image: winiotsaleskit.azurecr.io/onvif-camera-mocking:latest
           ports:
           - containerPort: 8554
           - containerPort: 1000
           - containerPort: 3702
           env:
           - name: INTERFACE
             value: "eth0"
           - name: DIRECTORY
             value: "/onvif-camera-mock"
           - name: MP4FILE
             value: /mnt/sample.mp4 
           volumeMounts:
           - name: sample-volume
             mountPath: /mnt
         volumes:
         - name: sample-volume
           hostPath:
             path: /home/aksedge-user
             type: Directory
   

3. Zastosuj kod YAML i upewnij się, że zasobnik jest uruchomiony:

   kubectl apply -f onvif-mock.yaml
   kubectl get pods
   

4. Aby włączyć reguły adresów IP dla tej makiety kamery ONVIF, które mają zostać odnalezione:

   • Jeśli twoja nazwa CNI to Flannel:

     Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev cni0"
     

   • Jeśli twój CNI to Calico:

     1. Znajdź adres IP pozornego kontenera ONVIF:

        kubectl get pods -o wide
        

     2. Znajdź nazwę interfejsu sieciowego zgodną z adresem IP zasobnika ONVIF (tj. cali909b8c65537):

        Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "route"
        

     3. Teraz włącz odnajdywanie ONVIF:

        Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev <insert interface name>"
        

   • Ponadto jeśli korzystasz z pełnego wdrożenia z przełącznikiem zewnętrznym, włącz dport 3702 i zapisz tabele IP:

     Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo iptables -A INPUT -p udp --dport 3702 -j ACCEPT"
     Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo sed -i '/-A OUTPUT -j ACCEPT/i-A INPUT -p udp -m udp --dport 3702 -j ACCEPT' /etc/systemd/scripts/ip4save"
     

Teraz możesz uruchomić Akri i odkryć wyśmiewane kamery ONVIF.

Uruchamianie Akri

1. Dodaj wykresy Akri Helm, jeśli jeszcze tego nie zrobiono:

   helm repo add akri-helm-charts https://project-akri.github.io/akri/
   

   Jeśli wcześniej dodano wykres narzędzia Akri helm, zaktualizuj repozytorium do najnowszej kompilacji:

   helm repo update
   

2. Zainstaluj narzędzie Akri przy użyciu narzędzia Helm. Podczas instalowania narzędzia Akri określ, że chcesz wdrożyć programy obsługi odnajdywania ONVIF, ustawiając wartość onvif.discovery.enabled=truehelm . Ponadto określ, że chcesz wdrożyć brokera wideo ONVIF:

   helm install akri akri-helm-charts/akri `
    --set onvif.discovery.enabled=true `
    --set onvif.configuration.enabled=true `
    --set onvif.configuration.capacity=2 `
    --set onvif.configuration.brokerPod.image.repository='ghcr.io/project-akri/akri/onvif-video-broker' `
    --set onvif.configuration.brokerPod.image.tag='latest'
   

   Dowiedz się więcej o ustawieniach konfiguracji ONVIF tutaj.

Otwieranie portu WS-Discovery

Aby klaster AKS Edge Essentials odnaleźć aparat, otwórz port dla usługi WS-Discovery (odnajdywanie dynamiczne usług internetowych), który jest protokołem odnajdywania multiemisji, który działa za pośrednictwem portu 3702TCP i UDP.

1. Uruchom następujące polecenie, aby otworzyć sport 3702 w węźle systemu Linux i zapisać tabele adresów IP:

   Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo iptables -A INPUT -p udp --sport 3702 -j ACCEPT"
   Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo sed -i '/-A OUTPUT -j ACCEPT/i-A INPUT -p udp -m udp --sport 3702 -j ACCEPT' /etc/systemd/scripts/ip4save"
   

2. Sprawdź, czy Akri może teraz odnaleźć aparat. Powinno zostać wyświetlone jedno wystąpienie Akri dla aparatu ONVIF:

   kubectl get akrii
   

   

Wdrażanie aplikacji internetowej do przesyłania strumieniowego wideo

1. Otwórz pusty plik YAML i skopiuj/wklej następującą zawartość do pliku:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: akri-video-streaming-app
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: akri-video-streaming-app
     template:
       metadata:
         labels:
           app: akri-video-streaming-app
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         serviceAccountName: akri-video-streaming-app-sa
         containers:
         - name: akri-video-streaming-app
           image: ghcr.io/project-akri/akri/video-streaming-app:latest-dev
           imagePullPolicy: Always
           env:
           - name: CONFIGURATION_NAME
             value: akri-onvif
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: akri-video-streaming-app
     namespace: default
     labels:
       app: akri-video-streaming-app
   spec:
     selector:
       app: akri-video-streaming-app
     ports:
     - name: http
       port: 80
       targetPort: 5000
     type: NodePort
   ---
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: akri-video-streaming-app-sa
   ---
   kind: ClusterRole
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: akri-video-streaming-app-role
   rules:
   - apiGroups: [""]
     resources: ["services"]
     verbs: ["list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: akri-video-streaming-app-binding
   roleRef:
     apiGroup: ""
     kind: ClusterRole
     name: akri-video-streaming-app-role
   subjects:
     - kind: ServiceAccount
       name: akri-video-streaming-app-sa
       namespace: default
   

2. Zapisz plik jako akri-video-streaming-app.yaml.

3. W oknie programu PowerShell zmień katalog na lokalizację pliku akri-video-straming-app.yaml i wdróż go w klastrze:

   kubectl apply -f akri-video-streaming-app.yaml
   

4. Upewnij się, że wszystkie zasobniki są uruchomione:

   

5. Znajdź adres IP węzła systemu Linux i port usługi aplikacji internetowej:

   Get-AksEdgeNodeAddr
   

   kubectl get svc
   

   

6. Teraz możesz wyświetlić materiał wideo, przechodząc do aplikacji internetowej, czyli <NODE IP>:<PORT OF SERVICE>:

   

Czyszczenie

1. Usuń aplikację internetową do przesyłania strumieniowego wideo:

   kubectl delete -f akri-video-streaming-app.yaml
   

2. Odinstaluj usługę Akri z klastra:

   helm delete akri
   

3. (Opcjonalnie) Jeśli użyto makiety aparatu ONVIF, usuń wdrożenie:

   kubectl delete -f onvif-mock.yaml
   

Następne kroki

Omówienie podstaw usługi AKS Edge