Découvrir les caméras ONVIF avec Akri

Article
10/17/2023

Akri est une interface de ressources Kubernetes qui vous permet d’exposer facilement des appareils feuille hétérogènes (tels que des caméras IP et des périphériques USB) en tant que ressources dans un cluster Kubernetes, et il détecte continuellement les nœuds qui ont accès à ces appareils pour planifier des charges de travail en fonction de ceux-ci. Akri est un projet de bac à sable CNCF destiné à la périphérie, qui gère l’apparence dynamique et la disparition des dispositifs à feuilles. Il prend actuellement en charge les protocoles OPC UA, ONVIF et udev, mais vous pouvez également implémenter des gestionnaires de protocoles personnalisés fournis par le modèle. Pour en savoir plus sur Akri, cliquez ici.

Cet article explique comment découvrir des caméras ONVIF connectées au même réseau que votre cluster AKS Edge Essentials. ONVIF est une norme ouverte du secteur pour les appareils de sécurité IP, couramment utilisé pour la surveillance vidéo. Pour en savoir plus sur les profils ONVIF, cliquez ici. Cette démonstration vous aide à commencer à utiliser Akri pour découvrir des caméras IP via le protocole ONVIF et les utiliser via un répartiteur vidéo qui vous permet de consommer les images de la caméra et de les afficher dans une application web.

Prérequis

Un déploiement sur une seule machine ou un déploiement complet d’AKS Edge Essentials opérationnel (si vous utilisez une caméra IP ONVIF réelle, vous devez créer un déploiement complet avec un commutateur externe).
Akri fonctionne uniquement sur Linux : utilisez des nœuds Linux pour cet exercice.
Une caméra IP ONVIF connectée au même réseau que votre cluster de commutateur externe ou un conteneur ONVIF fictif en cours d’exécution (étapes de déploiement comme suit).

Notes

Cet exemple de répartiteur ONVIF ne prend actuellement pas en charge la connexion aux caméras qui nécessitent une authentification. Pour exécuter cette démonstration, désactivez l’authentification sur votre caméra ONVIF.

Faux conteneur ONVIF

Si vous n’avez pas de caméra IP ONVIF, vous pouvez utiliser notre conteneur ONVIF fictif pour cet exercice. Le conteneur fictif fonctionne à la fois sur un seul ordinateur ou un déploiement complet.

(Facultatif) Si vous souhaitez configurer un flux vidéo RTSP personnalisé pour votre conteneur ONVIF, enregistrez votre vidéo mp4 (fonctionne mieux si la qualité est SD plutôt que HD) et copiez le fichier à partir du répertoire de votre machine hôte dans votre nœud Linux à l’aide de la commande suivante (veillez à remplacer le répertoire de l’ordinateur hôte et le nom du fichier vidéo approprié) :
```
Copy-AksEdgeNodeFile -FromFile C:\Users\WinIotUser\Downloads\sample.mp4 -toFile /home/aksedge-user/sample.mp4 -PushFile
```

Ouvrez un fichier YAML vide et copiez/collez le contenu suivant. Veillez à remplacer la valeur après par /mnt/ le nom de votre fichier vidéo sous MP4FILE. Enregistrez le fichier sous le nom 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

Appliquez le YAML et vérifiez que le pod est en cours d’exécution :
```
kubectl apply -f onvif-mock.yaml
kubectl get pods
```

Pour permettre la découverte des règles IP de cette caméra ONVIF factice :

Si votre CNI est Flannel :

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

Si votre CNI est Calico :
1. Recherchez l’adresse IP du conteneur ONVIF fictif :
```
kubectl get pods -o wide
```
2. Recherchez le nom de l’interface réseau qui correspond à l’adresse IP du pod ONVIF (c’est-à-dire cali909b8c65537) :
```
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "route"
```
3. Activez maintenant la découverte ONVIF :
```
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev <insert interface name>"
```

En outre, si vous exécutez un déploiement complet avec un commutateur externe, activez et dport 3702 enregistrez les tables 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"

Maintenant, vous êtes prêt à exécuter Akri et à découvrir la caméra ONVIF factice.

Exécuter Akri

Ajoutez les graphiques Akri Helm si vous ne l’avez pas déjà fait :
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Si vous avez déjà ajouté le graphique Helm Akri précédemment, mettez à jour votre dépôt pour la dernière version :
```
helm repo update
```
Installez Akri à l’aide de Helm. Lors de l’installation d’Akri, spécifiez que vous souhaitez déployer les gestionnaires de découverte ONVIF en définissant la valeur onvif.discovery.enabled=truehelm . En outre, spécifiez que vous souhaitez déployer le répartiteur vidéo 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'
```
En savoir plus sur les paramètres de configuration ONVIF ici.

Ouvrir le port WS-Discovery

Pour que le cluster AKS Edge Essentials découvre votre appareil photo, ouvrez le port pour WS-Discovery (Web Services Dynamic Discovery), qui est un protocole de découverte multidiffusion qui fonctionne sur le port 3702TCP et UDP .

Exécutez la commande suivante pour ouvrir sport 3702 dans le nœud Linux et enregistrer les tables 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"

Vérifiez qu’Akri peut maintenant découvrir votre appareil photo. Vous devriez voir un instance Akri pour votre caméra ONVIF :
```
kubectl get akrii
```

Déployer une application web de streaming vidéo

Ouvrez un fichier YAML vide et copiez/collez le contenu suivant dans le fichier :

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

Enregistrez le fichier sous akri-video-streaming-app.yaml.
Dans votre fenêtre PowerShell, remplacez le répertoire par l’emplacement de votre fichier akri-video-straming-app.yaml et déployez-le sur votre cluster :
```
kubectl apply -f akri-video-streaming-app.yaml
```
Assurez-vous que tous vos pods sont opérationnels :
Recherchez l’adresse IP de votre nœud Linux et le port de votre service d’application web :
```
Get-AksEdgeNodeAddr
```
```
kubectl get svc
```
Vous pouvez maintenant afficher les séquences vidéo en accédant à votre application web, à savoir <NODE IP>:<PORT OF SERVICE>:

Nettoyage

Supprimez l’application web de streaming vidéo :
```
kubectl delete -f akri-video-streaming-app.yaml
```
Désinstallez Akri de votre cluster :
```
helm delete akri
```
(Facultatif) Si vous avez utilisé la caméra ONVIF factice, supprimez le déploiement :
```
kubectl delete -f onvif-mock.yaml
```

Étapes suivantes

Vue d’ensemble d’AKS Edge Essentials

Partager via