Partager via

Déploiement de Native AOT

La publication de votre application en tant que Native AOT produit une application autonome compilée à l'avance (AOT) en code natif. Les applications AOT natives ont un temps de démarrage plus rapide et des empreintes mémoire plus petites. Ces applications peuvent s’exécuter sur des machines dont le runtime .NET n’est pas installé.

L’avantage de Native AOT est le plus significatif pour les charges de travail avec un grand nombre d’instances déployées, telles que l’infrastructure de cloud et les services hyperscale. .NET 8 ajoute la prise en charge ASP.NET Core pour AOT natif.

Le modèle de déploiement AOT natif utilise un compilateur de type ahead-of-time pour compiler l'IL en code natif au moment de la publication. Les applications natives AOT n’ont pas recours à un compilateur juste-à-temps (JIT) lors de leur exécution. Les applications AOT natives peuvent s’exécuter dans des environnements restreints où un JIT n’est pas autorisé. Les applications AOT natives ciblent un environnement d’exécution spécifique, tel que Linux x64 ou Windows x64, tout comme la publication d’une application autonome.

Conditions préalables

Visual Studio 2022 ou version ultérieure, y compris la charge de travail 'Développement Bureau avec C++' avec tous les composants par défaut.

Publier un AOT natif à l’aide de l’interface CLI

  1. Ajoutez <PublishAot>true</PublishAot> à votre fichier projet.

    Cette propriété active la compilation AOT native pendant la publication. Il active également l’analyse dynamique de l’utilisation du code lors de la génération et de la modification. Il est préférable de placer ce paramètre dans le fichier projet plutôt que de le transmettre sur la ligne de commande, car il contrôle les comportements en dehors de la publication.

    <PropertyGroup>
    <PublishAot>true</PublishAot>
</PropertyGroup>

  2. Publiez l'application pour un identificateur d'exécution spécifique à l'aide de dotnet publish -r <RID>.

    L’exemple suivant publie l’application pour Windows en tant qu’application AOT native sur un ordinateur avec les conditions préalables requises installées.

    dotnet publish -r win-x64 -c Release

    L’exemple suivant publie l’application pour Linux en tant qu’application AOT native. Un binaire AOT natif produit sur une machine Linux ne fonctionnera que sur la même version linux ou une version plus récente. Par exemple, le binaire AOT natif produit sur Ubuntu 20.04 va s’exécuter sur Ubuntu 20.04 et versions ultérieures, mais il ne va pas s’exécuter sur Ubuntu 18.04.

    dotnet publish -r linux-arm64 -c Release

L’application est disponible dans le répertoire de publication et contient tout le code nécessaire à son exécution, y compris une version supprimée du runtime coreclr.

Consultez les exemples AOT natifs disponibles dans le référentiel dotnet/samples sur GitHub. Les exemples incluent des fichiers Dockerfile Linux et Windows qui montrent comment automatiser l’installation des prérequis et publier des projets .NET avec AOT natif à l’aide de conteneurs.

Analyseurs de compatibilité AOT

La IsAotCompatible propriété est utilisée pour indiquer si une bibliothèque est compatible avec L’AOT natif. Considérez quand une bibliothèque définit la propriété IsAotCompatible à true, par exemple :

<PropertyGroup>
    <IsAotCompatible>true</IsAotCompatible>
</PropertyGroup>

La configuration précédente affecte une valeur par défaut true aux propriétés suivantes :

  • IsTrimmable
  • EnableTrimAnalyzer
  • EnableSingleFileAnalyzer
  • EnableAotAnalyzer

Ces analyseurs permettent de s’assurer qu’une bibliothèque est compatible avec L’AOT natif.

Vérifiez que les assemblies référencées sont compatibles avec AOT

Lorsque vous activez l’analyse AOT pour une bibliothèque, vous pouvez éventuellement activer la vérification que tous les assemblys référencés sont également annotés pour la compatibilité AOT en définissant la VerifyReferenceAotCompatibility propriété sur true:

<PropertyGroup>
  <IsAotCompatible>true</IsAotCompatible>
  <VerifyReferenceAotCompatibility>true</VerifyReferenceAotCompatibility>
</PropertyGroup>

Lorsque cette propriété est activée, l'analyseur avertit des assemblies référencées qui n'ont pas de métadonnées IsAotCompatible. Cela permet de s’assurer que toutes les dépendances de votre projet sont annotées pour la compatibilité AOT native. L’avertissement émis est IL3058.

Cette vérification est activée, car :

  • Toutes les bibliothèques compatibles AOT n’ont pas été mises à jour pour inclure les IsAotCompatible métadonnées.
  • L’avertissement peut être bruyant si vous avez de nombreuses dépendances qui fonctionnent correctement avec AOT natif, mais ne sont pas explicitement marquées comme telles.

Note

Les IsAotCompatible métadonnées d’assembly ont été introduites dans .NET 10. Les bibliothèques qui ont été publiées ciblant des versions antérieures de .NET n’ont pas cet attribut, même si elles ont été générées avec <IsAotCompatible>true</IsAotCompatible>.

Envisagez d’activer cette vérification lorsque vous souhaitez vous assurer que toutes vos dépendances sont explicitement marquées comme compatibles avec AOT par leurs auteurs.

Informations de débogage natives

Par défaut, la publication AOT native produit des informations de débogage dans un fichier distinct :

  • Linux : .dbg
  • Windows : .pdb
  • macOS : dossier .dSYM

Le fichier de débogage est nécessaire pour exécuter l’application sous le débogueur ou inspecter les vidages mémoire en cas de crash. Sur les plateformes de type Unix, définissez la propriété StripSymbols sur false afin d'inclure les informations de débogage dans le fichier binaire natif. L’inclusion d’informations de débogage rend le fichier binaire natif plus grand.

<PropertyGroup>
    <StripSymbols>false</StripSymbols>
</PropertyGroup>

Limitations du déploiement AOT natif

Les applications AOT natives présentent les limitations suivantes :

  • Aucun chargement dynamique, par exemple. Assembly.LoadFile
  • Aucune génération de code runtime, par exemple System.Reflection.Emit.
  • Pas de C++/CLI.
  • Windows : Pas de COM intégré.
  • Nécessite un découpage, qui présente des limitations.
  • Implique la compilation dans un seul fichier, qui a des incompatibilités connues.
  • Les applications incluent les bibliothèques runtime requises (comme les applications autonomes, augmentant leur taille par rapport aux applications dépendantes de l’infrastructure).
  • System.Linq.Expressions utilisez toujours leur forme interprétée, qui est plus lente que le code compilé généré par le runtime.
  • Les paramètres génériques remplacés par des arguments de type de struct ont du code spécialisé généré pour chaque instanciation. Dans le runtime dynamique, de nombreuses instanciations sont générées à la demande. Dans l'AOT natif, toutes les instanciations sont prégénérées. Cela peut avoir un impact significatif sur la taille du disque de l’application. Les méthodes virtuelles génériques et les méthodes d’instance générique auront également une instanciation pour chaque type d’implémentation ou de substitution.
  • Toutes les bibliothèques runtime ne sont pas entièrement annotées pour être compatibles avec AOT natif. Autrement dit, certains avertissements dans les bibliothèques runtime ne sont pas actionnables par les développeurs finaux.
  • Prise en charge des diagnostics pour le débogage et le profilage avec certaines limitations.
  • Prise en charge de certaines fonctionnalités ASP.NET Core. Pour plus d’informations, consultez prise en charge de ASP.NET Core pour Native AOT.

Le processus de publication analyse l’ensemble du projet et ses dépendances pour connaître les limitations possibles. Les avertissements sont émis pour chaque limitation que l’application publiée peut rencontrer lors de l’exécution.

Restrictions relatives à la plateforme/à l’architecture

Le tableau suivant présente les cibles de compilation prises en charge.

Plate-forme Architecture prise en charge Remarques
Fenêtres x64, Arm64
Linux x64, Arm64
macOS x64, Arm64
Ios Arm64 Prise en charge expérimentale
iOSSimulator x64, Arm64 Prise en charge expérimentale
tvOS Arm64 Prise en charge expérimentale
tvOSSimulator x64, Arm64 Prise en charge expérimentale
MacCatalyst x64, Arm64 Prise en charge expérimentale
Androïde x64, Arm64 Expérimental, pas d’interopérabilité Java intégrée

Pour plus d’informations sur la prise en charge de la plateforme en question avec Native AOT, suivez le lien du tableau.

  • Last updated on