On-premise Docker | IoT Routes

IoTRoutes via des Images Docker

IoTRoutes met à disposition des images Docker publiques, accompagnées d’une documentation de mise en place, afin de simplifier l’installation de la plateforme. Cette solution permet de mettre rapidement en place un environnement complet — à des fins de test, de démonstration ou même de production avec les fonctionnalités minimales.

Les images Docker sont disponibles pour les deux composants principaux de la plateforme :

Le serveur AOS (Application Object Server)
Le client web

Ces images sont accessibles dans le dépôt public officiel d’IoTRoutes sur Docker Hub :
👉 https://hub.docker.com/repositories/iotroutes

Ce chapitre décrit un exemple concret de déploiement du serveur IoTRoutes AOS et du client Web sur un environnement Kubernetes, en utilisant Nginx comme serveur web.

Avant de poursuivre, il est fortement recommandé de consulter les sections précédentes de la documentation décrivant l’architecture générale de la plateforme, afin de bien comprendre les composants à configurer et leurs interactions.

Rappelons qu'une installation minimale consiste à :

Installer et configurer une Instance de base de données MongoDB
Installer et configurer le serveur AOS fourni par IoTRoutes.
Installer et configurer le client web IoTRoutes.

✅ Prérequis

Avant de procéder au déploiement des composants IoTRoutes via Kubernetes, assurez-vous que les éléments suivants sont en place :

Un cluster Kubernetes fonctionnel (local ou distant)
Le Ingress NGINX est installé et opérationnel
Le Cert-Manager est configuré si vous utilisez TLS avec Let's Encrypt
Docker est disponible si vous personnalisez ou construisez les images localement

⚠️ Important – Configuration des adresses réseau
Dans les exemples de cette documentation (et dans les fichiers YAML fournis), deux adresses virtuelles sont utilisées à titre d’exemple :

https://my-aos-iotroutes-url.com → pour le serveur AOS
http://iotroutes.local → pour le client web

L’utilisateur doit prévoir des adresses IP, des noms DNS internes, ou des noms de domaine publics qui pointent vers le contrôleur Ingress de son cluster Kubernetes.

1. Serveur de base de données

IoTRoutes utilise des bases de données NoSQL pour la configuration de l'application et pour stocker les messages IoT ainsi que les fichiers media ou documents générer. MongoDB est optimisé pour l'application et aussi conseillé pour toutes installations on-premises. Vous pouvez consulter la documentation depuis le site officiel MongoDB pour l'installation ou l'utilisation cloud.

En production ,Il est fortement recommandé de créer des bases séparées pour Data et d'autres pour les documents, rapports générés et fichiers media.

2. Déploiement du Serveur IoTRoutes via Kubernetes

Le serveur AOS (backend principal d’IoTRoutes) peut être déployé via l’image Docker publique iotroutes/iotroutes.aos .
Cette section décrit comment configurer et lancer l’AOS dans un cluster Kubernetes, en utilisant trois fichiers YAML :

Une ConfigMap contenant la configuration de l'application (connexion base de données, sécurité, etc.)
Un Deployment pour exécuter l'image du serveur
Un Ingress pour exposer l'API AOS en HTTP(S)

L’installation expose un port pour le protocole MQTT, tel que défini dans le Deployment .
L’administrateur peut créer et gérer plusieurs brokers MQTT depuis l’interface ; il est donc nécessaire de prévoir l’exposition des ports correspondants selon les brokers activés dans votre déploiement.

🚀 Etape 1

📄 Fichier : iotroutes-aos-configmap.yaml

Ce fichier YAML définit une ConfigMap Kubernetes qui contient le fichier appsettings.json utilisé pour configurer le serveur AOS.

apiVersion: v1
kind: ConfigMap
metadata:
  name: iotroutes-aos-config
data:
  appsettings.json: |
    {
      "Logging": {
        "LogLevel": {
          "Default": "Error",
          "Microsoft": "Warning",
          "Microsoft.Hosting.Lifetime": "Warning"
        }
      },
      "ConnectionStrings": {
        "mongodbDataConnectionString": "mongodb://mongodbUser:Password@dbServer1Name:27017",
        "mongodbDataDbName": "myMainDatabase",
        "mongodbFilesConnectionString": "mongodb://mongodbUser:Password@dbServer2Name:27017",
        "mongodbFilesDbName": "MyFileBucketsDatabase"
      },
      "MQTTEndPointsURL": "",
      "AppServiceName": "iotroutes-aos",
      "Jwt": {
        "Jwt_Secret": "LONG-STRING-FOR-JWT-SECRET-HERE",
        "Jwt_TokenLifetime": "04:00:00",
        "Jwt_RefreshDuration": "04:15:00"
      },
      "Defaults": {
        "DefaultAdmin": {
          "Email": "admiUser@mail.com",
          "Password": "intialPassword"
        },
        "IoTProfiles": "EnvironmentalMonitoring,Lighting,seeMoreOnWebSite..."
      },
      "ApiRateLimit": {
        "Enabled": true,
        "DefaultPerMinute": 60,
        "PerRoute": {
            "/api/auth": 10,
            "/api/definition": 30,
            "/api/FileStore": 30
        }
      },
      "AllowOrigins": "https://my-aos-iotroutes-url.com,http://iotroutes.local"
    }

📝 Description des paramètres clés

Paramètre	Description
ConnectionStrings.mongodbDataConnectionString	Connexion MongoDB pour les données métiers
ConnectionStrings.mongodbFilesConnectionString	Connexion MongoDB pour les fichiers/documents
MQTTEndPointsURL	Pour les grandes plateformes avec plusieurs AOS et brokers. Fichier décrivant la stratégie de réservation des ports décrivant les points d’accès MQTT. Non requis pour un déploiement autonome
AppServiceName	Nom du service utilisé dans l’environnement AOS, sert comme préfixe pour les noms des Brokers sur les pods.
Jwt	Paramètres de sécurité pour la génération de tokens JWT
Defaults.DefaultAdmin	Admin par défaut créé au premier lancement, avec un mot de passe initial pour accéder à l'application qui doit être changé par la suite
Defaults.IoTProfiles	Profils IoT activés par défaut dans la plateforme
AllowOrigins	URLs autorisées pour le CORS (client web)
ApiRateLimit	Définit le nombre maximal d'appels API autorisés par minute et par utilisateur. Ce paramètre sert de protection à la passerelle, contribuant à préserver la plateforme contre les abus et les attaques par déni de service.

🔐 Note de sécurité : les valeurs sensibles (mot de passe , clé JWT, mot de passe admin) doivent être stockées dans un Secret Kubernetes en production. Ici, elles sont visibles à des fins de démonstration uniquement. Ici la documentation pour Kubernetes secrests

🚀 Etape 2

📄 Fichier : iotroutes-aos-deploy.yaml

Ce fichier contient trois objets Kubernetes :

Un Deployment qui lance le serveur AOS à partir de l’image Docker iotroutes/iotroutes.aos
Un Service HTTP (port 80) pour exposer l’API REST de la plateforme
Un Service MQTT (port 1883) pour les communications IoT avec les appareils

apiVersion: apps/v1
kind: Deployment
metadata:
  name: iotroutes-aos
spec:
  replicas: 1
  selector:
    matchLabels:
      app: iotroutes-aos
  template:
    metadata:
      labels:
        app: iotroutes-aos
    spec:
      containers:
        - name: iotroutes-aos
          image: iotroutes/iotroutes.aos:latest
          ports:
            - containerPort: 80
            - containerPort: 1883   # for MQTT broker
          env:
            - name: ASPNETCORE_URLS
              value: "http://0.0.0.0:80"
            - name: NODE_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.hostIP
          volumeMounts:
            - name: config-volume
              mountPath: /app/appsettings.json
              subPath: appsettings.json
      volumes:
        - name: config-volume
          configMap:
            name: iotroutes-aos-config
---
apiVersion: v1
kind: Service
metadata:
  name: iotroutes-aos
spec:
  selector:
    app: iotroutes-aos
  ports:
    - port: 80
      targetPort: 80    
  type: ClusterIP
---
apiVersion: v1
kind: Service
metadata:
  name: iotroutes-aos-mqtt
spec:
  selector:
    app: iotroutes-aos
  ports:
    - port: 1883           
      targetPort: 1883 
  type: LoadBalancer

*Note! dans certains environnements Kubernetes, le type de service LoadBalancer peut ne pas être supporté et qu’il faut utiliser NodePort ou un Ingress TCP (selon infrastructure).

🚀 Etape 2

📄 Fichier : iotroutes-aos-ingress.yaml

Ce fichier définit une ressource Ingress Kubernetes qui expose l’API HTTP du serveur AOS via un nom de domaine public sécurisé, avec TLS via Let's Encrypt, et la gestion du CORS activée pour permettre les appels depuis le client web.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: iotroutes-aos-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    cert-manager.io/cluster-issuer: letsencrypt-cert-manager
    nginx.ingress.kubernetes.io/enable-cors: "true"
    nginx.ingress.kubernetes.io/cors-allow-origin: "*"
    nginx.ingress.kubernetes.io/cors-allow-methods: "*"
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - my-aos-iotroutes-url.com
      secretName: my-letsencrypt-tls-secret
  rules:
    - host: my-aos-iotroutes-url
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: iotroutes-aos
                port:
                  number: 80

Apres avoir terminer la création et l'adaptation de ces fichiers selon votre déploiement. Veuillez les appliquer par les commandes suivantes :

kubectl apply -f iotroutes-aos-configmap.yaml
kubectl apply -f iotroutes-aos-deploy.yaml
kubectl apply -f iotroutes-aos-ingress.yaml

Une fois appliqué, ces fichiers :

Expose l’API du serveur AOS à l’adresse :
👉 https://my-aos-iotroutes-url.com
Génère automatiquement un certificat SSL valide (via Let’s Encrypt)
Permet aux applications (notamment le client web IoTRoutes) de consommer l’API via HTTPS
Autorise les appels cross-origin grâce aux CORS activés

3. Déploiement du Client Web IoTRoutes via Kubernetes

Cette section explique comment déployer le client web d’IoTRoutes à partir de l’image Docker publique iotroutes/iotroutes.web , dans un environnement Kubernetes.
Nous utiliserons les objets suivants :

ConfigMap : Ce fichier YAML définit une ConfigMap Kubernetes utilisée pour transmettre la configuration de l’application web IoTRoutes au moment du déploiement.
Deployment : pour lancer le conteneur du client web
Ingress : pour exposer le service via NGINX

🚀 Etape 1

📄 Créer et appliquer le fichier : iotroutes-web-configmap.yaml

Permettant de personnaliser :

Le titre de l’application (AppTitle)
Le logo affiché (AppLogo)
L’adresse du serveur AOS auquel le client doit se connecter (AOSAddresses)

apiVersion: v1
kind: ConfigMap
metadata:
  name: iotroutes-web-config
data:
  appSetting.json: |
    {
      "AppTitle": "My IoTRoutes",
      "AppLogo": "assets/logo.png",
      "AOSAddresses": {
        "default": "https://my-aos-iotroutes-url.com"
      }
    }

Appliquer la configuration:

kubectl apply -f iotroutes-web-deploy.yaml

🚀 Etape 2

📄 Créer et appliquer le fichier : iotroutes-web-deploy.yaml

Ce déploiement crée un Pod basé sur l’image iotroutes/iotroutes.web , en important la configuration précédente.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: iotroutes-web
spec:
  replicas: 1
  selector:
    matchLabels:
      app: iotroutes-web
  template:
    metadata:
      labels:
        app: iotroutes-web
    spec:
      containers:
        - name: iotroutes-web
          image: iotroutes/iotroutes.web:latest
          ports:
            - containerPort: 80
          volumeMounts:
            - name: config-volume
              mountPath: /usr/share/nginx/html/assets/appSetting.json
              subPath: appSetting.json           
      volumes:
        - name: config-volume
          configMap:
            name: iotroutes-web-config
---
apiVersion: v1
kind: Service
metadata:
  name: iotroutes-web
spec:
  selector:
    app: iotroutes-web
  ports:
    - port: 80
      targetPort: 80
  type: ClusterIP

Appliquer le déploiement :

kubectl apply -f iotroutes-web-deploy.yaml

🚀 Etape 3

📄 Créer et appliquer le fichier : iotroutes-web-ingress.yaml

Ce fichier définit les règles d'accès HTTP, en exposant l'interface web d'IoTRoutes via un nom de domaine ou IP.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: iotroutes-web-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - iotroutes.local
  rules:
    - host: iotroutes.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: iotroutes-web
                port:
                  number: 80

Remarque : Pour un déploiement en production, utiliser ici un certificat SSL pour sécuriser l'accès en https

Appliquer pour configurer Ingress :

kubectl apply -f iotroutes-web-ingress.yaml

Une fois tous les objets déployés :

Accédez à l'URL définie dans le fichier Ingress (ex. : http://iotroutes.local/ )
L’interface web devrait s’ouvrir et tenter de se connecter à l’AOS via l’URL définie dans la ConfigMap.

Suivant : IoTRoutes on-premise Web Client

IoTRoutes via des Images Docker

✅ Prérequis

1. Serveur de base de données

2. Déploiement du Serveur IoTRoutes via Kubernetes

🚀 Etape 1

📝 Description des paramètres clés

🚀 Etape 2

🚀 Etape 2

3. Déploiement du Client Web IoTRoutes via Kubernetes

🚀 Etape 1

🚀 Etape 2

🚀 Etape 3

Docs navigation

Stay connected

Contact

LiM Products

IoT

Recent Posts