Individuare le fotocamere ONVIF con Akri

Akri è un'interfaccia delle risorse Kubernetes che consente di esporre facilmente dispositivi foglia eterogenei (ad esempio telecamere IP e dispositivi USB) come risorse in un cluster Kubernetes e rileva continuamente i nodi che hanno accesso a questi dispositivi per pianificare i carichi di lavoro in base a essi. Akri è un progetto sandbox CNCF realizzato per il bordo, gestendo l'aspetto dinamico e la scomparsa di dispositivi foglia. Attualmente supporta protocolli OPC UA, ONVIF e udev, ma è anche possibile implementare gestori di protocolli personalizzati forniti dal modello. Altre informazioni su Akri sono disponibili qui.

Questo articolo descrive come individuare le fotocamere ONVIF connesse alla stessa rete del cluster Azure Kubernetes Edge Essentials. ONVIF è uno standard di settore aperto per i dispositivi di sicurezza IP, comunemente usato per la sorveglianza video. Altre informazioni sui profili ONVIF sono disponibili qui. Questa demo consente di iniziare a usare Akri per individuare le telecamere IP tramite il protocollo ONVIF e usarle tramite un broker video che consente di usare le riprese dalla fotocamera e di visualizzarla in un'applicazione Web.

Prerequisiti

• Distribuzione a computer singolo o distribuzione completa di Azure Kubernetes Edge Essentials in esecuzione (se si usa una fotocamera IP ONVIF reale, è necessario creare una distribuzione completa con un commutatore esterno).
• Akri funziona solo in Linux: usare nodi Linux per questo esercizio.
• Una fotocamera IP ONVIF connessa alla stessa rete del cluster commutatore esterno o un contenitore ONVIF fittizio in esecuzione (procedura di distribuzione come indicato di seguito).

Nota

Questo broker ONVIF di esempio attualmente non supporta la connessione alle telecamere che richiedono l'autenticazione. Per eseguire questa demo, disabilitare l'autenticazione nella fotocamera ONVIF.

Contenitore ONVIF fittizio

Se non si dispone di una fotocamera IP ONVIF, è possibile usare il contenitore ONVIF fittizio per questo esercizio. Il contenitore fittizio funziona sia in un singolo computer che in una distribuzione completa.

1. (Facoltativo) Se si vuole configurare un feed video RTSP personalizzato per il contenitore ONVIF, salvare il video mp4 (funziona meglio se la qualità è SD anziché HD) e copiare il file dalla directory del computer host nel nodo Linux usando il comando seguente (assicurarsi di sostituire la directory del computer host e il nome del file video appropriato):

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

2. Aprire un file YAML vuoto e copiare/incollare il contenuto seguente. Assicurarsi di sostituire il valore dopo /mnt/ con il nome del file video in MP4FILE. Salvare il file come 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. Applicare YAML e assicurarsi che il pod sia in esecuzione:

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

4. Per abilitare le regole IP per la fotocamera ONVIF fittizia da individuare:

   • Se il CNI è Flannel:

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

   • Se il CNI è Calico:

     1. Trovare l'IP del contenitore ONVIF fittizio:

        kubectl get pods -o wide
        

     2. Trovare il nome dell'interfaccia di rete corrispondente all'IP del pod ONVIF (ad esempio cali909b8c65537):

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

     3. Abilitare ora l'individuazione ONVIF:

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

   • Inoltre, se si esegue una distribuzione completa con un commutatore esterno, abilitare dport 3702 e salvare le tabelle 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"
     

Ora sei pronto per eseguire Akri e scopri la fotocamera ONVIF fittizia.

Eseguire Akri

1. Aggiungere i grafici Akri Helm se non sono già stati:

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

   Se in precedenza è stato aggiunto il grafico helm Akri, aggiornare il repository per la build più recente:

   helm repo update
   

2. Installare Akri usando Helm. Quando si installa Akri, specificare che si desidera distribuire i gestori di individuazione ONVIF impostando il valore onvif.discovery.enabled=truehelm . Specificare anche che si vuole distribuire il broker video 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'
   

   Altre informazioni sulle impostazioni di configurazione ONVIF sono disponibili qui.

Aprire la porta WS-Discovery

Per individuare la fotocamera, aprire la porta per WS-Discovery (Individuazione dinamica servizi Web), ovvero un protocollo di individuazione multicast che opera sulla porta 3702TCP e UDP.

1. Eseguire il comando seguente per aprire sport 3702 all'interno del nodo Linux e salvare le tabelle 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. Verificare che Akri possa ora individuare la fotocamera. Verrà visualizzata un'istanza di Akri per la fotocamera ONVIF:

   kubectl get akrii
   

   

Distribuire un'applicazione Web di streaming video

1. Aprire un file YAML vuoto e copiare/incollare il contenuto seguente nel file:

   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. Salvare il file come akri-video-streaming-app.yaml.

3. Nella finestra di PowerShell modificare la directory nel percorso del file akri-video-straming-app.yaml e distribuirlo nel cluster:

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

4. Assicurarsi che tutti i pod siano in esecuzione:

   

5. Trovare l'INDIRIZZO IP del nodo Linux e la porta del servizio app Web:

   Get-AksEdgeNodeAddr
   

   kubectl get svc
   

   

6. È ora possibile visualizzare i video passando all'applicazione Web, ovvero <NODE IP>:<PORT OF SERVICE>:

   

Eseguire la pulizia

1. Eliminare l'applicazione Web di streaming video:

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

2. Disinstallare Akri dal cluster:

   helm delete akri
   

3. (Facoltativo) Se è stata usata la fotocamera ONVIF fittizia, eliminare la distribuzione:

   kubectl delete -f onvif-mock.yaml
   

Passaggi successivi

Panoramica di Azure Kubernetes Edge Essentials