Entdecken Sie ONVIF-Kameras mit Akri

Artikel
10/27/2023

Akri ist eine Kubernetes-Ressourcenschnittstelle, mit der Sie auf einfache Weise heterogene Blattgeräte (z. B. IP-Kameras und USB-Geräte) als Ressourcen in einem Kubernetes-Cluster verfügbar machen können, und es erkennt kontinuierlich Knoten, die Zugriff auf diese Geräte haben, um workloads basierend darauf zu planen. Akri ist ein CNCF-Sandboxprojekt, das für den Rand erstellt wurde und das dynamische Aussehen und Das Verschwinden von Blattgeräten behandelt. Derzeit werden OPC UA-, ONVIF- und udev-Protokolle unterstützt, Sie können aber auch benutzerdefinierte Protokollhandler implementieren, die von der Vorlage bereitgestellt werden. Weitere Informationen zu Akri finden Sie hier.

In diesem Artikel wird beschrieben, wie Sie ONVIF-Kameras ermitteln können, die mit demselben Netzwerk wie Ihr AKS Edge Essentials-Cluster verbunden sind. ONVIF ist ein offener Industriestandard für IP-Sicherheitsgeräte, der häufig für die Videoüberwachung verwendet wird. Weitere Informationen zu ONVIF-Profilen finden Sie hier. Diese Demo hilft Ihnen, mit Akri zu beginnen, IP-Kameras über das ONVIF-Protokoll zu ermitteln und sie über einen Videobroker zu verwenden, mit dem Sie das Filmmaterial von der Kamera nutzen und es in einer Webanwendung anzeigen können.

Voraussetzungen

Eine Bereitstellung mit einem einzelnen Computer oder eine vollständige Bereitstellung von AKS Edge Essentials, die ausgeführt wird (wenn Sie eine echte ONVIF-IP-Kamera verwenden, müssen Sie eine vollständige Bereitstellung mit einem externen Switch erstellen).
Akri funktioniert nur unter Linux: Verwenden Sie für diese Übung Linux-Knoten.
Eine ONVIF-IP-Kamera, die mit demselben Netzwerk wie Ihr externer Switchcluster verbunden ist, oder ein simulierter ONVIF-Container, der ausgeführt wird (Bereitstellungsschritte wie folgt).

Hinweis

Dieser ONVIF-Beispielbroker unterstützt derzeit keine Verbindung mit Kameras, die eine Authentifizierung erfordern. Um diese Demo auszuführen, deaktivieren Sie die Authentifizierung auf Ihrer ONVIF-Kamera.

Simulierter ONVIF-Container

Wenn Sie keine ONVIF-IP-Kamera haben, können Sie für diese Übung unseren simulierten ONVIF-Container verwenden. Der Mockcontainer funktioniert sowohl auf einem einzelnen Computer als auch auf einer vollständigen Bereitstellung.

(Optional) Wenn Sie einen benutzerdefinierten RTSP-Videofeed für Ihren ONVIF-Container einrichten möchten, speichern Sie Ihr mp4-Video (funktioniert am besten, wenn die Qualität SD statt HD ist), und kopieren Sie die Datei aus dem Verzeichnis Ihres Hostcomputers mit dem folgenden Befehl in Ihren Linux-Knoten (ersetzen Sie unbedingt das Hostcomputerverzeichnis und den entsprechenden Videodateinamen):
```
Copy-AksEdgeNodeFile -FromFile C:\Users\WinIotUser\Downloads\sample.mp4 -toFile /home/aksedge-user/sample.mp4 -PushFile
```

Öffnen Sie eine leere YAML-Datei, und kopieren/fügen Sie den folgenden Inhalt ein. Ersetzen Sie den Wert nach /mnt/ durch den Namen Ihrer Videodatei unter MP4FILE. Speichern Sie die Datei als 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

Wenden Sie yaML an, und stellen Sie sicher, dass der Pod ausgeführt wird:
```
kubectl apply -f onvif-mock.yaml
kubectl get pods
```

So können Sie die IP-Regeln für diese OnVIF-Modellkamera ermitteln:

Wenn Ihr CNI Flannel ist:

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

Wenn Ihr CNI Calico ist:
1. Suchen Sie die IP-Adresse des simulierten ONVIF-Containers:
```
kubectl get pods -o wide
```
2. Suchen Sie den Netzwerkschnittstellennamen, der der IP-Adresse des ONVIF-Pods entspricht (d. h. cali909b8c65537):
```
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "route"
```
3. Aktivieren Sie nun die ONVIF-Ermittlung:
```
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev <insert interface name>"
```

Wenn Sie eine vollständige Bereitstellung mit einem externen Switch ausführen, aktivieren Sie außerdem die dport 3702 IP-Tabellen, und speichern Sie sie:

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"

Jetzt sind Sie bereit, Akri auszuführen und die simulierte ONVIF-Kamera zu entdecken.

Ausführen von Akri

Fügen Sie die Akri Helm-Diagramme hinzu, wenn Sie dies noch nicht getan haben:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Wenn Sie bereits ein Akri Helm-Diagramm hinzugefügt haben, aktualisieren Sie Ihr Repository für den neuesten Build:
```
helm repo update
```
Installieren Sie Akri mithilfe von Helm. Geben Sie beim Installieren von Akri an, dass Sie die ONVIF-Ermittlungshandler bereitstellen möchten, indem Sie den helm-Wert onvif.discovery.enabled=truefestlegen. Geben Sie außerdem an, dass Sie den ONVIF-Videobroker bereitstellen möchten:
```
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'
```
Weitere Informationen zu den ONVIF-Konfigurationseinstellungen finden Sie hier.

Öffnen des WS-Discovery-Ports

Damit der AKS Edge Essentials-Cluster Ihre Kamera ermitteln kann, öffnen Sie den Port für WS-Discovery (Dynamische Ermittlung von Webdiensten), bei dem es sich um ein Multicastermittlungsprotokoll handelt, das über TCP- und UDP-Port 3702ausgeführt wird.

Führen Sie den folgenden Befehl aus, um im Linux-Knoten zu öffnen sport 3702 und die IP-Tabellen zu speichern:

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"

Vergewissern Sie sich, dass Akri ihre Kamera jetzt ermitteln kann. Es sollte ein Akri-instance für Ihre ONVIF-Kamera angezeigt werden:
```
kubectl get akrii
```

Bereitstellen einer Videostreaming-Webanwendung

Öffnen Sie eine leere YAML-Datei, und kopieren/fügen Sie den folgenden Inhalt in die Datei ein:

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

Speichern Sie die Datei als akri-video-streaming-app.yaml.
Ändern Sie in Ihrem PowerShell-Fenster das Verzeichnis in den Speicherort Ihrer Datei akri-video-straming-app.yaml , und stellen Sie es in Ihrem Cluster bereit:
```
kubectl apply -f akri-video-streaming-app.yaml
```
Stellen Sie sicher, dass alle Ihre Pods ausgeführt werden:
Suchen Sie Ihre Linux-Knoten-IP und den Port Ihres Web-App-Diensts:
```
Get-AksEdgeNodeAddr
```
```
kubectl get svc
```
Nun können Sie das Videomaterial anzeigen, indem Sie zu Ihrer Webanwendung navigieren:<NODE IP>:<PORT OF SERVICE>

Bereinigung

Löschen Sie die Videostreaming-Webanwendung:

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

Deinstallieren Sie Akri aus Ihrem Cluster:
```
helm delete akri
```
(Optional) Wenn Sie die Simulierte ONVIF-Kamera verwendet haben, löschen Sie die Bereitstellung:
```
kubectl delete -f onvif-mock.yaml
```

Nächste Schritte

Übersicht über AKS Edge Essentials

Freigeben über