Upptäck ONVIF-kameror med Akri

Artikel
10/17/2023

Akri är ett Kubernetes-resursgränssnitt som gör att du enkelt kan exponera heterogena lövenheter (till exempel IP-kameror och USB-enheter) som resurser i ett Kubernetes-kluster, och det identifierar kontinuerligt noder som har åtkomst till dessa enheter för att schemalägga arbetsbelastningar baserat på dem. Akri är ett CNCF-sandbox-projekt som skapats för gränsen, som hanterar det dynamiska utseendet och försvinnandet av lövenheter. Det stöder för närvarande OPC UA-, ONVIF- och udev-protokoll, men du kan också implementera anpassade protokollhanterare som tillhandahålls av mallen. Läs mer om Akri här.

Den här artikeln beskriver hur du kan identifiera ONVIF-kameror som är anslutna till samma nätverk som AKS Edge Essentials-klustret. ONVIF är en öppen branschstandard för IP-säkerhetsenheter, som ofta används för videoövervakning. Läs mer om ONVIF-profiler här. Den här demonstrationen hjälper dig att komma igång med Akri för att identifiera IP-kameror via ONVIF-protokollet och använda dem via en videokoordinator som gör att du kan använda filmen från kameran och visa den i ett webbprogram.

Förutsättningar

En distribution av en enda dator eller fullständig distribution av AKS Edge Essentials igång (om du använder en riktig ONVIF IP-kamera måste du skapa en fullständig distribution med en extern växel).
Akri fungerar bara på Linux: använd Linux-noder för den här övningen.
En ONVIF IP-kamera som är ansluten till samma nätverk som ditt externa växelkluster eller en falsk ONVIF-container som körs (distributionsstegen nedan).

Anteckning

Det här exemplet på ONVIF-asynkron meddelandekö stöder för närvarande inte anslutning till kameror som kräver autentisering. Om du vill köra den här demonstrationen inaktiverar du autentisering på ONVIF-kameran.

Mock ONVIF-container

Om du inte har en ONVIF IP-kamera kan du använda vår falska ONVIF-container för den här övningen. Den falska containern fungerar både på en enskild dator eller en fullständig distribution.

(Valfritt) Om du vill konfigurera ett anpassat RTSP-videoflöde för din ONVIF-container sparar du mp4-videon (fungerar bäst om kvaliteten är SD i stället för HD) och kopierar filen från värddatorkatalogen till Linux-noden med följande kommando (se till att ersätta värddatorkatalogen och lämpligt videofilnamn):
```
Copy-AksEdgeNodeFile -FromFile C:\Users\WinIotUser\Downloads\sample.mp4 -toFile /home/aksedge-user/sample.mp4 -PushFile
```

Öppna en tom YAML-fil och kopiera/klistra in följande innehåll. Se till att ersätta värdet efter /mnt/ med videofilens namn under MP4FILE. Spara filen som 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

Använd YAML och kontrollera att podden körs:

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

Så här aktiverar du IP-reglerna för den här falska ONVIF-kameran:

Om din CNI är flanell:

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

Om ditt CNI är Calico:

Hitta IP-adressen för en falsk ONVIF-container:
```
kubectl get pods -o wide
```
Hitta nätverksgränssnittets namn som matchar IP-adressen för ONVIF-podden (dvs. cali909b8c65537):
```
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "route"
```

Aktivera nu ONVIF-identifieringen:

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

Om du dessutom kör en fullständig distribution med en extern växel aktiverar dport 3702 och sparar du IP-tabellerna:

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"

Nu är du redo att köra Akri och upptäcka den falska ONVIF-kameran.

Kör Akri

Lägg till Akri Helm-diagrammen om du inte redan har gjort det:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Om du redan har lagt till Akri Helm-diagram tidigare uppdaterar du lagringsplatsen för den senaste versionen:
```
helm repo update
```

Installera Akri med Helm. När du installerar Akri anger du att du vill distribuera ONVIF-identifieringshanterare genom att ange helm-värdet onvif.discovery.enabled=true. Ange också att du vill distribuera ONVIF-videokoordinatorn:

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'

Läs mer om konfigurationsinställningarna för ONVIF här.

Öppna porten WS-Discovery

För att AKS Edge Essentials-klustret ska kunna identifiera kameran öppnar du porten för WS-Discovery (Web Services Dynamic Discovery), som är ett multicast-identifieringsprotokoll som körs via TCP- och UDP-porten 3702.

Kör följande kommando för att öppna sport 3702 i Linux-noden och spara IP-tabellerna:

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"

Kontrollera att Akri nu kan identifiera kameran. Du bör se en Akri-instans för din ONVIF-kamera:
```
kubectl get akrii
```

Distribuera webbprogram för videouppspelning

Öppna en tom YAML-fil och kopiera/klistra in följande innehåll i filen:

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

Spara filen som akri-video-streaming-app.yaml.
I PowerShell-fönstret ändrar du katalogen till platsen för filen akri-video-straming-app.yaml och distribuerar den till klustret:
```
kubectl apply -f akri-video-streaming-app.yaml
```
Kontrollera att alla poddar är igång:
Hitta din Linux-nod-IP och porten för webbapptjänsten:
```
Get-AksEdgeNodeAddr
```
```
kubectl get svc
```
Nu kan du visa videofilmerna genom att gå till webbappen, som är <NODE IP>:<PORT OF SERVICE>:

Rensa

Ta bort webbappen för videoströmning:

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

Avinstallera Akri från klustret:
```
helm delete akri
```
(Valfritt) Om du använde den falska ONVIF-kameran tar du bort distributionen:
```
kubectl delete -f onvif-mock.yaml
```

Nästa steg

Översikt över AKS Edge Essentials

Dela via