Guide OPC-UA complet pour l'industrie : architecture, sécurité, implémentation

· 11 minutes de lecture
11 min read
Équipe Eziwan
Équipe Eziwan
Infrastructure IoT

OPC-UA (OPC Unified Architecture) est devenu le protocole de référence pour l'interopérabilité dans l'industrie 4.0. Pourtant, sa complexité apparente freine encore beaucoup d'implémentations. Ce guide pratique démystifie OPC-UA : architecture, sécurité, NodeId, implémentation Python/Node.js, et intégration cloud.

Qu'est-ce qu'OPC-UA et pourquoi ça compte ?​

OPC-UA (IEC 62541) est un protocole de communication indépendant de la plateforme, conçu pour l'échange sécurisé de données industrielles. Contrairement à son prédécesseur OPC-DA (Windows only, DCOM), OPC-UA fonctionne sur n'importe quel OS (Linux, Windows, embedded RTOS) et sur n'importe quel réseau (Ethernet, 4G, Wi-Fi).

Pourquoi OPC-UA domine l'industrie 4.0​

  • Interopérabilité : un serveur Siemens S7-1500 OPC-UA est lisible sans driver propriétaire par n'importe quel client conforme
  • Modèle d'information : les données ont un sens (unité, description, historique), pas seulement une valeur
  • Sécurité native : chiffrement, authentification, certificats — intégrés dans le protocole
  • Profils de conformité : un sous-ensemble léger pour les petits équipements embedded
  • Pubsub & MQTT : extension OPC-UA Pub/Sub pour architectures cloud (IEC 62541-14)

Architecture OPC-UA : les concepts fondamentaux​

Client-Serveur​

Le modèle de base OPC-UA est client-serveur :

  • Serveur OPC-UA : exposé par l'équipement (PLC, IHM, serveur de données)
  • Client OPC-UA : consomme les données (SCADA, gateway, application cloud)

Un même équipement peut être serveur et client simultanément (ex. gateway qui agrège plusieurs PLCs et expose les données consolidées).

Address Space et NodeId​

L'Address Space est l'arbre d'information exposé par un serveur OPC-UA. Chaque nœud a un NodeId unique :

Format NodeId :

  • ns=2;i=1234 — namespace 2, identifiant entier 1234
  • ns=2;s=Station_1.Pression — namespace 2, identifiant chaîne
  • ns=0;i=2258 — namespace 0 (standard), ServerStatus

Namespaces :

  • ns=0 : namespace OPC-UA standard (types, méthodes)
  • ns=1 : souvent le namespace constructeur
  • ns=2+ : namespaces applicatifs (vos données)

Modes de communication​

ModeDescriptionCas d'usage
ReadLecture ponctuelle d'un nœudPolling toutes les N secondes
SubscriptionAbonnement à des changements (MonitoredItem)Événements, alarmes
BrowseExploration de l'Address SpaceConfiguration, discovery
WriteÉcriture d'une valeurSetpoints, commandes
Method CallAppel de méthodeActions complexes
PubsubPublication/abonnement MQTT ou UDPArchitectures cloud massives

Les Subscriptions sont la bonne approche pour la supervision temps réel : au lieu de poller toutes les secondes, le client s'abonne à un nœud et reçoit une notification uniquement quand la valeur change au-delà d'un seuil configurable (DeadbandValue).

Sécurité OPC-UA : le guide complet​

La sécurité est l'un des points forts d'OPC-UA — et aussi l'une des sources de complexité. Voici les concepts essentiels.

Modes de sécurité​

ModeConfidentialitéIntégritéAuthentificationUsage
NoneAucuneAucuneAucuneTests, réseau isolé
SignNonSignatureCertificatRéseau sécurisé
SignAndEncryptAES-256SignatureCertificatInternet, cloud
attention

Ne jamais utiliser SecurityMode: None en production sur un réseau accessible depuis l'extérieur.

Certificats X.509​

OPC-UA utilise des certificats X.509 pour l'authentification mutuelle client-serveur :

Création d'un certificat auto-signé pour tests :

# Avec OpenSSL
openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \
  -keyout client_key.pem -out client_cert.pem \
  -subj "/CN=EziwanGateway/O=Eziwan/C=FR" \
  -extensions v3_req \
  -config <(cat /etc/ssl/openssl.cnf; echo "[v3_req]"; echo "subjectAltName=URI:urn:eziwan:gateway:client")

En production : utiliser une PKI interne ou un CA reconnu. Les certificats doivent être échangés manuellement entre client et serveur la première fois.

Authentification utilisateur​

En plus des certificats machine, OPC-UA gère l'authentification utilisateur :

  • Anonymous : pas d'authentification (si autorisé par le serveur)
  • Username/Password : login applicatif
  • Certificate : certificat utilisateur X.509
  • IssuedToken : token JWT ou Kerberos

Implémenter OPC-UA en Python​

La bibliothèque python-opcua (ou sa fork asyncua) est la référence en Python.

Installation​

pip install asyncua

Client OPC-UA Python — lire des données​

import asyncio
from asyncua import Client

async def main():
    url = "opc.tcp://192.168.1.10:4840/freeopcua/server/"
    
    async with Client(url=url) as client:
        # Lire un nœud par NodeId
        node = client.get_node("ns=2;s=Station_1.Pression")
        value = await node.read_value()
        print(f"Pression: {value} bar")
        
        # Lire plusieurs nœuds en batch
        nodes = [
            client.get_node("ns=2;s=Station_1.Pression"),
            client.get_node("ns=2;s=Station_1.Debit"),
            client.get_node("ns=2;s=Station_1.Defaut"),
        ]
        values = await client.read_values(nodes)
        for node, val in zip(nodes, values):
            print(f"  {node}: {val}")

asyncio.run(main())

Client OPC-UA Python — abonnement (Subscription)​

import asyncio
from asyncua import Client
from asyncua.common.subscription import SubHandler

class DataChangeHandler(SubHandler):
    def datachange_notification(self, node, val, data):
        print(f"[CHANGE] {node} = {val}")
    
    def event_notification(self, event):
        print(f"[EVENT] {event}")

async def main():
    url = "opc.tcp://192.168.1.10:4840"
    
    async with Client(url=url) as client:
        handler = DataChangeHandler()
        subscription = await client.create_subscription(500, handler)  # 500ms
        
        nodes = [
            client.get_node("ns=2;s=Station_1.Pression"),
            client.get_node("ns=2;s=Station_1.Debit"),
        ]
        
        monitored_items = await subscription.subscribe_data_change(nodes)
        print("Subscriptions actives, attente changements...")
        
        await asyncio.sleep(30)  # écouter 30 secondes
        await subscription.unsubscribe(monitored_items)

asyncio.run(main())

Connexion sécurisée avec certificat​

from asyncua.crypto.security_policies import SecurityPolicyBasic256Sha256
from asyncua.crypto.cert_man import CertificateManager

async def connect_secure():
    client = Client("opc.tcp://192.168.1.10:4840")
    
    await client.set_security(
        SecurityPolicyBasic256Sha256,
        certificate="./client_cert.der",
        private_key="./client_key.pem",
        server_certificate="./server_cert.der"
    )
    
    await client.connect()
    # ... vos opérations
    await client.disconnect()

Implémenter OPC-UA en Node.js​

La bibliothèque node-opcua est la référence JavaScript/TypeScript.

npm install node-opcua

Lecture de données​

const opcua = require("node-opcua");

const client = opcua.OPCUAClient.create({
    endpointMustExist: false,
    connectionStrategy: { maxRetry: 5, initialDelay: 2000 }
});

const endpointUrl = "opc.tcp://192.168.1.10:4840";

async function main() {
    await client.connect(endpointUrl);
    const session = await client.createSession();
    
    const nodeToRead = {
        nodeId: "ns=2;s=Station_1.Pression",
        attributeId: opcua.AttributeIds.Value
    };
    
    const dataValue = await session.read(nodeToRead);
    console.log(`Pression: ${dataValue.value.value} bar`);
    console.log(`Timestamp: ${dataValue.serverTimestamp}`);
    
    await session.close();
    await client.disconnect();
}

main().catch(console.error);

OPC-UA sur les principaux automates industriels​

Siemens S7-1500 / S7-1200​

Le S7-1500 supporte OPC-UA serveur natif depuis le firmware 2.0 :

  • Port : 4840 (TCP)
  • Configuration dans TIA Portal : Device Configuration → OPC UA → Server
  • Activer les nœuds souhaités dans l'Access configuration
  • Authentification : Certificats ou Username/Password

Le S7-1200 supporte OPC-UA depuis le firmware 4.1.

Schneider Electric M580 / M340​

M580 : OPC-UA via module BMENOC0311 (firmware ≥ V2.0) M340 : pas de support OPC-UA natif → Modbus TCP recommandé, ou gateway OPC-UA to Modbus (ex. Kepware KEPServerEX)

Allen-Bradley / Rockwell (EtherNet/IP)​

Les automates Rockwell ne supportent pas OPC-UA natif. Options :

  • KEPServerEX (Kepware) : bridge EtherNet/IP → OPC-UA
  • FactoryTalk Linx Gateway : serveur OPC-UA pour l'écosystème Rockwell
  • Eziwan Gateway : connexion directe EtherNet/IP/Modbus, exposition API REST

Beckhoff TwinCAT 3​

TwinCAT 3 intègre un serveur OPC-UA natif via TF6100 (module OPC-UA). Configuration via TwinCAT System Manager.

Wago / Phoenix Contact / Pilz​

La plupart des PLC modernes de ces constructeurs supportent OPC-UA. Vérifier le firmware et activer le serveur dans la configuration réseau.

OPC-UA PubSub : l'extension pour le cloud​

OPC-UA PubSub (IEC 62541-14) est l'extension qui rend OPC-UA compatible avec les architectures IoT cloud :

  • Publisher : l'équipement publie ses données sur un Message Oriented Middleware
  • Subscriber : le cloud ou SCADA s'abonne au flux

Transports supportés :

  • AMQP (port 5672)
  • MQTT (port 1883 ou 8883) — le plus utilisé en IoT
  • UDP Multicast (réseau local)

Encodages :

  • JSON (lisible, debug facile)
  • UADP (binaire, compact, embarqué)

Exemple de message OPC-UA PubSub JSON :

{
  "MessageId": "abc123",
  "PublisherId": "urn:station1:plc",
  "DataSetWriterId": 1,
  "MetaDataVersion": {"MajorVersion": 1, "MinorVersion": 0},
  "Timestamp": "2026-08-14T10:30:00.000Z",
  "Payload": {
    "Station_1.Pression": {"Value": 4.2, "StatusCode": 0, "SourceTimestamp": "2026-08-14T10:29:59.950Z"},
    "Station_1.Debit": {"Value": 125.3, "StatusCode": 0, "SourceTimestamp": "2026-08-14T10:29:59.950Z"}
  }
}

Migration OPC-DA vers OPC-UA​

Si vous avez des installations sous OPC-DA (OPC Classic, Windows DCOM), la migration vers OPC-UA apporte :

  • Suppression de la dépendance Windows/DCOM
  • Compatibilité Linux / Raspberry Pi / PLCs Linux
  • Chiffrement (absent dans OPC-DA)
  • Accès internet direct (impossible avec DCOM sans VPN complexe)

Outil de migration : OPC UA Wrapper (ex. Kepware) crée un serveur OPC-UA qui expose les données d'un serveur OPC-DA existant, permettant une migration progressive.

OPC-UA avec le Gateway Eziwan​

Le Eziwan Gateway intègre un client OPC-UA capable de se connecter aux serveurs OPC-UA de vos équipements :

  • Connexion Siemens S7-1500 OPC-UA (port 4840)
  • Connexion à tout serveur OPC-UA conforme IEC 62541
  • Support des modes de sécurité None, Sign, SignAndEncrypt
  • Configuration des NodeIds dans l'interface cloud (browse automatique de l'Address Space)
  • Transmission des données vers la plateforme cloud Eziwan en MQTT/TLS

Avantage clé : vous n'avez pas besoin d'écrire un client OPC-UA vous-même. Le gateway fait le travail et expose une API REST vers votre SCADA ou ERP.

FAQ — OPC-UA​

OPC-UA est-il plus complexe que Modbus ? Oui, mais justifié pour les installations multi-constructeurs et les projets industrie 4.0. Pour une installation avec 2-3 automates du même constructeur, Modbus TCP peut être suffisant. OPC-UA s'impose quand vous avez des équipements hétérogènes, des exigences de sécurité, ou des besoins d'interopérabilité ERP/MES.

Le port 4840 doit-il être ouvert sur mon firewall ? En architecture "zero-inbound-port" (comme Eziwan), le gateway initie la connexion vers le serveur OPC-UA en interne. Aucun port n'est ouvert depuis l'extérieur. Le tunnel VPN chiffré porte les données vers le cloud.

OPC-UA peut-il remplacer MQTT dans une architecture IoT ? OPC-UA PubSub avec transport MQTT combine le meilleur des deux : le modèle d'information sémantique d'OPC-UA avec la légèreté et la scalabilité de MQTT. C'est la direction prise par les référentiels Industrie 4.0 (Industrie 4.0 Architecture Reference Model, IDS-R).

Quelles performances attendre d'un serveur OPC-UA embarqué ? Un Siemens S7-1500 CPU 1515 peut traiter ~10 000 nœuds OPC-UA en lecture par seconde. Pour les PLCs moins puissants (M221, petits WAGO), limiter le polling OPC-UA à 100-500 nœuds/s. Les abonnements (Subscription) sont beaucoup plus efficaces que le polling pour les volumes importants.

Existe-t-il des serveurs OPC-UA gratuits pour tester ? Oui : ProsysOPC UA Simulation Server (gratuit, Windows), Node-RED avec node-red-contrib-opcua (gratuit, multi-plateforme), python-opcua en mode serveur (exemple dans la doc GitHub). Ils permettent de tester un client sans avoir de PLC physique.

Pour aller plus loin​

Besoin d'aide pour connecter vos serveurs OPC-UA au cloud ? Demandez une démo gratuite — notre équipe vous accompagne du POC au déploiement.

Ressources complémentaires​