Porter des modules critiques en WebAssembly et Rust sans tout réécrire
Porter des modules critiques en WebAssembly et Rust sans tout réécrire est désormais une démarche de portabilité, pas nécessairement un projet de remplacement de l’application. L’enjeu consiste à isoler la logique qui apporte de la valeur, à lui donner une interface stable, puis à choisir un format de composant et un hôte capables de fournir les services dont elle dépend.
Pour une équipe produit, cela change la question à poser : plutôt que « faut-il réécrire notre système en WebAssembly ? », demandez-vous quelles parties Rust peuvent être conservées, quelles dépendances doivent être adaptées et dans quels environnements le module devra s’exécuter. Le Component Model, WASI et les outils de liaison rendent ce chemin plus accessible, mais ils ne suppriment ni les contraintes de l’hôte ni le besoin de vérifier chaque frontière d’intégration.
Porter des modules Rust en WebAssembly sans réécriture : la réponse courte
Oui, un module critique écrit en Rust peut être porté vers WebAssembly sans réécrire toute l’application. La voie la plus pragmatique consiste à conserver la logique métier, à isoler ses entrées et sorties derrière une interface explicite, puis à compiler et relier le module à un hôte compatible.
Le principe : réutiliser le code Rust qui exprime le métier, remplacer ou adapter seulement les dépendances liées à son environnement, et traiter l’interface du composant comme un contrat à tester.
Cette approche évite de confondre trois opérations différentes : compiler du code Rust vers le format WebAssembly de base, lui donner accès aux capacités d’un environnement particulier, et l’intégrer à d’autres modules ou à une application hôte. La compilation seule ne garantit pas que le programme sera portable. WebAssembly spécifie les imports, mais ne définit pas à lui seul les API ou les appels système disponibles. Le runtime et ses interfaces déterminent donc ce que le module peut réellement faire.
Pour une équipe, le résultat attendu n’est pas forcément un composant universel qui fonctionne immédiatement partout. Il peut s’agir d’un noyau métier Rust réutilisable dans plusieurs produits, entouré d’adaptateurs propres à chaque hôte. Le choix du Component Model et de WASI devient particulièrement pertinent lorsque l’objectif est de partager des modules entre environnements plutôt que de produire un binaire destiné à un seul usage.
Pourquoi le Component Model facilite la réutilisation de modules critiques
Le WebAssembly de base définit une cible d’exécution, mais il ne fournit pas un catalogue commun de capacités telles que l’accès au système de fichiers, au réseau ou aux API du navigateur. Ces ressources sont apportées par l’environnement hôte. C’est la raison pour laquelle deux runtimes capables de charger du WebAssembly ne présentent pas nécessairement les mêmes fonctions au code invité.
Le Component Model répond à une partie de ce problème en décrivant des interfaces de plus haut niveau entre composants. La documentation Rust sur la cible wasm32_wasip2 présente cette interopérabilité comme une approche « shared-nothing » : les composants échangent par des API explicites, plutôt que de s’appuyer sur un modèle de mémoire partagée de bas niveau. Cette séparation rend les responsabilités plus lisibles et fournit un contrat autour duquel organiser la réutilisation.
Une frontière claire plutôt qu’un accès implicite
Dans une application traditionnelle, une bibliothèque peut dépendre de types, de variables globales, de callbacks ou de conventions propres à son processus. À la frontière d’un composant, ces dépendances doivent être représentées par des fonctions et des types que l’hôte et le module comprennent. Cela peut demander de concevoir une interface, mais ne signifie pas de réécrire la logique interne de calcul ou les règles métier.
Une interface bien délimitée peut, par exemple, exposer une opération de validation avec une entrée structurée et un résultat explicite. Le composant n’a pas besoin de connaître le framework d’interface utilisateur qui l’appelle. De son côté, l’hôte conserve la responsabilité de récupérer les données, de gérer les permissions et de présenter le résultat. Le module devient ainsi réutilisable sans rendre l’application entière indépendante de son runtime.
-
Le code métier reste dans une bibliothèque Rust quand ses dépendances le permettent.
-
Les fonctions exposées définissent les entrées, les sorties et les erreurs attendues.
-
Les capacités propres à l’environnement sont fournies par l’hôte ou par un adaptateur.
-
Les autres composants dépendent du contrat publié, pas des détails internes du module.
Cette organisation est utile lorsque plusieurs applications doivent appeler la même fonctionnalité sans partager la même pile technique. Elle est également intéressante pour réduire les dépendances entre équipes : une évolution interne du module peut rester invisible aux consommateurs si le contrat public ne change pas.
Le contrat ne rend pas les environnements identiques
Le Component Model aide à définir des échanges, mais ne rend pas automatiquement disponibles les mêmes ressources dans tous les hôtes. Il faut encore vérifier que le runtime implémente les interfaces requises, que les permissions sont configurées et que les formats de données correspondent aux besoins du produit. Un module portable sur le plan de son interface peut donc nécessiter un adaptateur différent dans le navigateur, un service côté serveur ou un autre runtime.
Il faut aussi éviter de présenter le composant comme une garantie de remplacement transparent. Le passage d’un appel de fonction interne à une frontière de composant introduit une interface à maintenir et des règles de conversion de données à définir. La bonne question est de savoir si cette frontière rend la réutilisation et l’évolution plus simples que le couplage actuel, et non si elle efface toute complexité.
Choisir la bonne partie du système à porter
Le meilleur candidat n’est pas automatiquement le module le plus volumineux, ni celui qui utilise le plus de calcul. Commencez par une capacité dont la responsabilité est identifiable et dont les dépendances peuvent être inventoriées. Un algorithme métier, un moteur de règles ou un traitement de données peut être un candidat pertinent si son comportement est déjà testable indépendamment de l’interface qui l’appelle.
À l’inverse, une partie étroitement liée à un framework, à des services du système d’exploitation ou à un état global partagé peut nécessiter beaucoup d’adaptations. Elle n’est pas forcément impossible à porter, mais l’effort ne se limite alors plus à changer de cible de compilation. Il faut décider si l’on accepte de remplacer ces dépendances, de les exposer par des interfaces hôtes ou de laisser cette partie dans son environnement d’origine.
Faire l’inventaire avant de compiler
Un audit court permet de séparer le code réutilisable des responsabilités liées à l’environnement. Pour chaque module pressenti, examinez les entrées et sorties, les dépendances directes et indirectes, ainsi que les hypothèses faites sur l’exécution. Il est utile de noter les fonctions qui lisent des fichiers, appellent le réseau, accèdent à une horloge ou attendent un service externe, sans présumer que ces capacités seront présentes dans chaque runtime.
-
Décrire la fonction métier. Formulez ce que le module reçoit, ce qu’il produit et quelles erreurs il peut retourner. Si cette description dépend déjà d’un framework ou d’un stockage particulier, identifiez cette dépendance comme un premier travail de découplage.
-
Tracer les dépendances d’exécution. Distinguez les bibliothèques Rust purement logiques des interfaces système, des accès externes et des mécanismes propres à l’application. La compatibilité d’une bibliothèque ne se déduit pas de son langage : elle dépend aussi de ce qu’elle attend de son environnement.
-
Définir la frontière d’intégration. Choisissez des types et des opérations compréhensibles par l’hôte. Limitez les détails internes exposés, mais ne réduisez pas tellement l’interface qu’elle oblige l’hôte à reconstruire une grande partie de la logique métier.
-
Tester le comportement existant. Des tests de référence permettent de vérifier que le module porté continue de respecter ses règles. Ils sont particulièrement importants lorsque des conversions de données ou des adaptateurs s’intercalent entre l’appelant et le code Rust.
-
Évaluer l’hôte cible. Vérifiez les interfaces disponibles et les capacités que l’environnement autorise. Un même module peut être réutilisable dans plusieurs hôtes, mais chaque intégration doit être validée dans son contexte réel.
Cette démarche aide à définir une première tranche livrable. Par exemple, une équipe peut commencer par rendre une fonction métier appelable derrière une interface de composant, puis traiter séparément l’accès aux ressources externes. Elle obtient ainsi une information concrète sur les adaptations nécessaires avant de transformer plusieurs modules à la fois.
Critères pour décider si le portage vaut l’effort
Évaluez le coût de l’adaptation en regard de la valeur de la réutilisation. Si une même logique doit être embarquée dans plusieurs produits, si elle doit être isolée derrière un contrat ou si l’équipe veut réduire sa dépendance à un runtime précis, le composant peut apporter une structure utile. Si le module est profondément lié à une API hôte unique et qu’aucun besoin de réutilisation n’est identifié, une bibliothèque Rust classique ou une intégration native peut être plus simple.
Le coût ne se mesure pas uniquement au nombre de lignes modifiées. Il comprend la conception et la version des interfaces, la génération ou l’entretien des bindings, la configuration du runtime, les tests d’intégration et l’observabilité en production. Il faut également tenir compte de la capacité de l’équipe à maintenir ces éléments. Un prototype qui compile ne constitue pas, à lui seul, une validation du coût opérationnel.
Conserver la logique Rust et adapter les frontières
Porter sans tout réécrire signifie généralement préserver le cœur du module et revoir la façon dont celui-ci communique avec le reste du système. La logique métier peut être organisée dans une bibliothèque Rust sans dépendre d’un point d’entrée spécifique. Une couche d’adaptation peut ensuite traduire les types et les appels attendus par le Component Model ou par une API hôte particulière.
Cette séparation donne à l’équipe plusieurs niveaux de changement. Les règles métier restent testées avec leurs tests Rust habituels ; les adaptateurs portent les conversions et l’intégration ; le contrat de composant décrit ce qui est accessible de l’extérieur. Si une application conserve un besoin de compatibilité avec une interface JavaScript existante, les bindings peuvent être générés au lieu de réécrire manuellement toute la passerelle.
Faire de l’interface un choix d’architecture
La documentation WebAssembly de Rust met en avant la génération automatique de code de liaison entre Rust, WebAssembly et les API JavaScript. C’est un point important pour un portage pragmatique : le travail manuel ne doit pas se déplacer de la logique métier vers une quantité disproportionnée de code d’interopérabilité. Les outils et les bindings prennent en charge une partie de cette frontière, mais l’équipe reste responsable de la forme et de la stabilité de l’interface.
Pour concevoir cette interface, privilégiez des opérations qui correspondent aux besoins du produit plutôt qu’une exposition mécanique de toutes les fonctions internes. Une API trop proche de l’implémentation oblige les consommateurs à connaître des détails qui devraient rester privés. Une API excessivement générale, au contraire, peut rendre les erreurs difficiles à diagnostiquer et le contrat difficile à faire évoluer.
Prévoyez également une représentation explicite des erreurs. Une erreur interne, un refus de capacité par l’hôte et une entrée invalide ne signifient pas la même chose pour l’appelant. Les distinguer au contrat évite que les adaptateurs masquent un problème ou que le produit transforme une défaillance d’intégration en résultat métier apparemment valide.
Trois couches utiles à maintenir distinctes
-
Le noyau métier : les règles, calculs et transformations qui doivent être réutilisés. Il reste au plus près du Rust existant et ne devrait pas dépendre inutilement du runtime.
-
L’adaptateur de composant : la traduction entre les types internes et l’interface exposée. Il peut inclure les bindings générés et le code nécessaire à la liaison.
-
L’hôte : l’application ou le runtime qui fournit les capacités, applique les permissions et décide comment appeler le composant.
Cette décomposition est une recommandation d’architecture, pas une obligation de créer trois paquets distincts. Pour un module modeste, les couches peuvent rester dans le même dépôt ou le même projet, à condition que leurs responsabilités soient visibles et testables. L’objectif est d’éviter qu’une dépendance de plateforme contamine peu à peu la logique que l’on cherchait précisément à réutiliser.
Le Component Model se prête à des interfaces partagées entre composants, mais le contrat doit être traité comme un élément du produit. Documentez les changements, vérifiez les consommateurs et testez les versions prises en charge. Cette discipline est particulièrement utile quand le module critique évolue indépendamment de l’application qui l’héberge.
Traiter l’asynchrone sans reconstruire une passerelle ad hoc
Les modules critiques ne sont pas toujours des fonctions synchrones qui reçoivent une valeur et en retournent une autre. Ils peuvent attendre un résultat, consommer un flux ou participer à une chaîne d’opérations asynchrones. Jusqu’ici, le passage de ces comportements à travers plusieurs interfaces pouvait demander une couche de glue spécifique à l’environnement. L’évolution de WASI 0.3 place l’asynchrone au niveau des primitives de composants.
WASI 0.3 a été officiellement lancé le 11 juin 2026. Dans cette version, async func, future<T> et stream<T> sont présentés comme des primitives de première classe du Component Model plutôt que comme une convention ad hoc. Cela donne un vocabulaire commun pour décrire des opérations asynchrones à une frontière de composant et ouvre une voie plus structurée pour déplacer du code Rust qui dépend de ces échanges.
Ce que changent les primitives asynchrones
La documentation de lancement de Bytecode Alliance décrit le comportement d’un future pouvant réveiller la tâche en attente après que sa valeur a traversé plusieurs frontières de composants. Ce détail compte pour une architecture composée de modules : l’attente ne doit pas être supposée s’arrêter au premier appelant. Le modèle vise à rendre le passage de résultats asynchrones cohérent au-delà d’une seule couche.
Pour l’équipe qui porte un module, cela ne veut pas dire que toutes les bibliothèques asynchrones Rust fonctionnent sans adaptation ni que chaque runtime expose immédiatement les mêmes capacités. Il faut examiner les interfaces utilisées, l’outillage de génération et le support offert par l’hôte visé. Les primitives fournissent un cadre d’échange ; elles ne remplacent pas l’analyse des dépendances ni les tests d’intégration.
Un bon exercice consiste à décrire le cycle complet d’une opération : qui démarre la tâche, qui attend, comment un résultat ou une erreur remonte, et quelles ressources sont nécessaires pendant l’attente. Puis vérifiez que le contrat de composant exprime ce cycle sans obliger l’hôte à connaître les détails internes du runtime Rust. Cette modélisation est plus utile qu’une conversion mécanique de chaque fonction asynchrone en interface publique.
Quand choisir une interface synchrone
Une opération asynchrone dans le code source n’a pas nécessairement besoin d’être exposée comme telle à la frontière. Si le module peut terminer son travail dans le cadre d’un appel simple et que l’attente ne doit pas être coordonnée avec d’autres composants, une interface synchrone peut offrir un contrat plus facile à intégrer. En revanche, pour des attentes longues, des résultats livrés ultérieurement ou des flux continus, la représentation asynchrone mérite d’être considérée.
Le choix doit refléter le comportement réel du produit, pas une préférence générale pour un style d’API. Ajouter une interface asynchrone sans besoin clair peut compliquer les appels et les tests. À l’inverse, simuler un flux ou une attente par des mécanismes de glue locaux peut rendre le module plus difficile à déplacer. WASI 0.3 rend ces options plus explicites, mais la décision reste liée au contrat et au runtime retenu.
Choisir la cible Rust et les outils de liaison
L’écosystème Rust évolue au-delà de la voie historique wasm32-unknown-unknown. Les objectifs du projet Rust pour 2026 incluent l’amélioration du support des composants WebAssembly, l’ajout et la stabilisation de nouvelles cibles, ainsi que l’expérimentation avec des fonctionnalités du langage spécifiques à WebAssembly. Cette orientation répond directement aux besoins des bases de code existantes : réduire les frictions de portabilité plutôt que demander un nouveau développement complet.
Les cibles mentionnées dans ces objectifs sont wasm32-wasip3 au niveau Tier 2, ainsi que wasm32-component et wasm32-component-web au niveau Tier 3. Ces niveaux ne doivent pas être interprétés comme une promesse que chaque cible convient à chaque application. Ils indiquent plutôt que plusieurs parcours sont en cours de construction, avec des contextes d’usage et des degrés de stabilisation distincts à vérifier avant de choisir une cible de production.
Une étape de stabilisation concrète pour WASI 0.3
La cible wasm32-wasip3 est devenue stable avec Rust 1.100 le 12 novembre 2026. À partir de cette version, la documentation du Component Model indique qu’il n’est plus nécessaire d’utiliser une chaîne nightly pour cette cible et que la commande cargo build --target=wasm32-wasip3 fonctionne avec Rust stable. Pour une équipe qui portait déjà du code Rust, cette étape réduit une friction du parcours vers WASI 0.3 : elle permet de s’appuyer sur la chaîne stable pour cette cible.
La commande de compilation ne constitue toutefois qu’une étape du flux. Il faut aussi définir les interfaces, produire ou relier le composant, vérifier les capacités de l’hôte et exécuter les tests dans le runtime visé. La documentation du Component Model fournit des indications propres à Rust pour créer des composants exécutables et configurer les bindings de l’hôte. Le fait que Rust soit traité comme un langage invité de premier plan facilite l’apprentissage du parcours, mais ne remplace pas son intégration dans la chaîne de livraison de l’équipe.
Les bindings sont utiles, mais restent un chantier actif
Les objectifs Rust de 2026 signalent qu’exporter et importer des types et fonctions WebAssembly demande encore des outils bindgen tiers. Améliorer cette expérience fait partie des travaux prévus. C’est une nuance importante : l’écosystème progresse pour rendre le portage plus naturel, mais une équipe doit aujourd’hui tenir compte de l’outillage externe, de ses versions et de la façon dont ses artefacts s’intègrent au build.
Un billet Rust d’avril 2026 sur les cibles WebAssembly et les symboles indéfinis confirme que la manière de lier et de présenter les cibles Wasm aux outils externes est activement durcie. Il mentionne notamment l’interaction avec des outils comme wasm-bindgen et wasm-tools component new. En pratique, cela invite à figer une chaîne reproductible dans l’intégration continue, à vérifier les versions utilisées et à traiter les changements d’outils comme des évolutions susceptibles d’affecter le packaging.
Deux mécanismes de l’écosystème illustrent cette recherche de parité d’outillage. jco peut transcompiler des composants vers du WebAssembly de base accompagné de glue JavaScript. De son côté, le parcours C-ABI invité permet à des toolchains de viser le Component Model via des en-têtes générés et l’éditeur de liens wasm-component-ld. Ces voies peuvent réduire la quantité de logique applicative à réécrire, mais elles impliquent des compromis d’intégration distincts : choisissez selon les outils du projet et les exigences de l’hôte, pas uniquement selon le nom de la cible.
Un flux de travail prudent pour une première tranche
-
Stabilisez le module Rust. Séparez la logique réutilisable de l’application, définissez ses entrées et sorties et conservez les tests qui décrivent son comportement attendu.
-
Sélectionnez une cible selon l’hôte. Comparez le besoin d’un environnement WASI, d’une intégration orientée navigateur ou d’une autre cible WebAssembly. Vérifiez le niveau de support et les capacités réellement fournies.
-
Décrivez le contrat du composant. Limitez l’interface aux opérations utiles, choisissez la représentation des erreurs et précisez les dépendances que l’hôte doit fournir.
-
Générez et reliez les bindings. Intégrez les outils requis dans le build et gardez la génération reproductible. Évitez de confondre le code généré avec la logique métier à maintenir à la main.
-
Testez dans l’environnement d’exécution visé. Vérifiez les appels, les types, les erreurs et les capacités hôtes, puis comparez les résultats fonctionnels avec les tests de référence.
-
Décidez de l’extension du portage. À partir des limites constatées, choisissez de porter un autre module, d’ajouter un adaptateur ou de conserver certaines fonctions dans l’hôte d’origine.
Pour un premier essai, choisissez une tranche assez petite pour être comprise et assez représentative pour faire apparaître les vrais points d’intégration. Un exemple artificiel qui n’utilise aucune dépendance ne permet pas de savoir si le module critique pourra être porté. À l’inverse, migrer d’un seul coup une grande partie du système rend les causes des problèmes plus difficiles à isoler.
Vérifier les limites de l’hôte, du navigateur et des alternatives
La portabilité de WebAssembly dépend toujours de l’environnement. La documentation de portabilité rappelle que Wasm spécifie les imports, et non un ensemble universel d’API ou d’appels système. Un module ne peut donc pas présumer qu’un service sera disponible simplement parce qu’il a été compilé pour WebAssembly. C’est à l’hôte de fournir les interfaces appropriées, et à l’équipe de vérifier qu’elles correspondent au contrat du composant.
Cette contrainte change la façon d’évaluer une migration. Faites une liste des capacités nécessaires au module, puis mettez-la en regard de celles que l’hôte sait réellement offrir. Si une dépendance n’est pas disponible, trois options restent possibles : la déplacer dans l’hôte et la rendre accessible par une interface, remplacer la dépendance par une alternative compatible, ou conserver le module dans son environnement actuel. Ce choix peut être fait capacité par capacité plutôt que pour l’application entière.
Le navigateur : une possibilité à préparer, pas une promesse
Le Component Model est également positionné comme une voie possible pour le navigateur. Bytecode Alliance indique que des éditeurs de navigateurs ont manifesté un intérêt pour un support natif des composants et que le travail de fond est engagé afin qu’ils puissent, à terme, appeler directement des API web depuis Rust sans passer par des allers-retours JavaScript. Cette direction ouvre une perspective de portabilité, mais elle ne signifie pas qu’un composant peut aujourd’hui supposer un support natif identique dans tous les navigateurs.
Pour une application web, distinguez donc le format de module de l’intégration concrète. Les bindings entre Rust, WebAssembly et JavaScript permettent déjà de relier du code à des API JavaScript par le biais d’outils. La transcompilation de composants par jco vers du Wasm de base et de la glue JavaScript constitue une autre piste décrite dans l’écosystème. Une équipe peut ainsi expérimenter la réutilisation de composants en navigateur sans attendre que toutes les fonctions de la plateforme soient exposées nativement, tout en gardant à l’esprit le coût de cette couche d’intégration.
Si le code dépend de capacités web, identifiez où elles sont appelées et gardez-les derrière une interface. La logique qui transforme des données peut alors être partagée, tandis que l’accès aux API du navigateur reste un détail de l’adaptateur approprié. Ce partage ne veut pas dire que chaque ligne de code est commune entre tous les environnements ; il signifie que les responsabilités peuvent être séparées pour éviter de dupliquer la partie réellement indépendante de l’hôte.
Comparer avec les options plus simples
WebAssembly n’est pas automatiquement le meilleur choix pour toute bibliothèque Rust. Si l’application et la bibliothèque restent dans le même environnement et qu’aucune frontière d’isolation ou de portabilité n’est recherchée, une bibliothèque native peut éviter la gestion supplémentaire des composants et de leurs bindings. Si l’application doit appeler des API spécifiques au navigateur, une intégration JavaScript directe peut être adaptée, notamment quand le module Rust ne représente qu’une petite partie de la fonctionnalité.
Le recours au Component Model se justifie davantage quand l’interface explicite entre modules apporte une valeur : réutilisation dans différents hôtes, composition de composants ou volonté de séparer clairement les capacités fournies par l’hôte de la logique invitée. WASI devient pertinent lorsque les besoins d’exécution correspondent aux interfaces que l’hôte prend en charge. Dans tous les cas, vérifiez les besoins réels plutôt que de choisir une cible sur la seule base de la nouveauté de l’écosystème.
Une comparaison raisonnable inclut également la maintenance. Un module WebAssembly demande une chaîne de compilation, des bindings et des tests adaptés. Une bibliothèque native peut imposer ses propres contraintes de compilation et de distribution. Une passerelle JavaScript peut être directe au départ, mais devenir coûteuse si ses types et conversions sont maintenus manuellement. Le critère utile est le coût global de la frontière sur la durée, pas une préférence abstraite pour une technologie.
Mettre en place des tests qui reflètent la frontière
Les tests unitaires du noyau Rust restent utiles, mais ils ne valident pas les échanges entre le composant et son hôte. Ajoutez des tests d’intégration qui vérifient les signatures exposées, les valeurs transmises, le traitement des erreurs et les capacités auxquelles le module peut accéder. Pour un flux asynchrone, vérifiez également le comportement de l’attente et la remontée du résultat à travers les frontières effectivement utilisées par le produit.
Les tests doivent s’exécuter avec les outils et le runtime de la chaîne retenue. Cela aide à détecter les problèmes de liaison, de bindings générés ou de configuration que des tests exécutés uniquement dans le code Rust ne révéleraient pas. Lorsque plusieurs hôtes sont visés, maintenez des tests propres à chacun pour éviter de confondre la portabilité du contrat avec l’équivalence des capacités disponibles.
Enfin, vérifiez les exigences opérationnelles propres au produit : comment le composant est construit, chargé, versionné et diagnostiqué. Les faits disponibles sur le Component Model et les cibles Rust décrivent une voie technique en développement, pas une garantie que tous les aspects d’exploitation sont identiques d’un runtime à l’autre. Traitez les détails de déploiement comme une partie du portage, au même titre que l’interface et la compilation.
Porter des modules critiques en WebAssembly et Rust sans tout réécrire repose donc sur un compromis maîtrisé : conserver les règles métier qui restent indépendantes, expliciter les échanges, et déplacer seulement les dépendances qui bloquent l’exécution dans l’hôte choisi. Le Component Model, les primitives asynchrones de WASI 0.3 et les progrès des cibles Rust rendent cette approche plus concrète, sans rendre les environnements interchangeables par défaut.
Pour avancer, choisissez un module représentatif, cartographiez ses dépendances, définissez une interface étroite et testez-la dans le runtime réellement visé. Si la frontière simplifie la réutilisation sans imposer une couche d’intégration disproportionnée, vous disposerez d’une base solide pour étendre le portage. Si ce n’est pas le cas, garder certaines responsabilités dans l’hôte ou retenir une intégration plus simple reste une décision d’architecture valable.
