Publier des applications .NET Core avec l’interface CLIPublish .NET Core apps with the CLI

Cet article montre comment vous pouvez publier votre application .NET Core à partir de la ligne de commande.This article demonstrates how you can publish your .NET Core application from the command line. .NET Core offre trois manières de publier des applications..NET Core provides three ways to publish your applications. Le déploiement dépendant du framework génère un fichier .dll multiplateforme qui utilise le runtime .NET Core installé localement.Framework-dependent deployment produces a cross-platform .dll file that uses the locally installed .NET Core runtime. L’exécutable dépendant du framework génère un exécutable propre à la plateforme qui utilise le runtime .NET Core installé localement.Framework-dependent executable produces a platform-specific executable that uses the locally installed .NET Core runtime. L’exécutable autonome génère un exécutable propre à la plateforme et inclut une copie locale du runtime .NET Core.Self-contained executable produces a platform-specific executable and includes a local copy of the .NET Core runtime.

Pour obtenir une vue d’ensemble de ces modes de publication, consultez Déploiement d’applications .NET Core.For an overview of these publishing modes, see .NET Core Application Deployment.

Vous recherchez une aide rapide sur l’utilisation de l’interface CLI ?Looking for some quick help on using the CLI? Le tableau suivant présente quelques exemples illustrant comment publier votre application.The following table shows some examples of how to publish your app. Vous pouvez spécifier le framework cible avec le paramètre -f <TFM> ou en modifiant le fichier projet.You can specify the target framework with the -f <TFM> parameter or by editing the project file. Pour plus d’informations, consultez Principes de base de la publication.For more information, see Publishing basics.

Mode de publicationPublish Mode Version du kit SDKSDK Version CommandeCommand
Déploiement dépendant du frameworkFramework-dependent deployment 2.x2.x dotnet publish -c Release
Exécutable dépendant du frameworkFramework-dependent executable 2.22.2 dotnet publish -c Release -r <RID> --self-contained false
3.03.0 dotnet publish -c Release -r <RID> --self-contained false
3.0*3.0* dotnet publish -c Release
Déploiement autonomeSelf-contained deployment 2.12.1 dotnet publish -c Release -r <RID> --self-contained true
2.22.2 dotnet publish -c Release -r <RID> --self-contained true
3.03.0 dotnet publish -c Release -r <RID> --self-contained true

*Quand vous utilisez un déploiement dépendant du framework avec la version 3.0 du SDK, il s’agit du mode de publication par défaut lors de l’exécution de la commande dotnet publish de base.* When using SDK version 3.0, framework-dependent executable is the default publishing mode when running the basic dotnet publish command. Cela s’applique uniquement à un projet qui cible .NET Core 2.1 ou .NET Core 3.0.This only applies when the project targets either .NET Core 2.1 or .NET Core 3.0.

Principes de base de la publicationPublishing basics

Le paramètre <TargetFramework> du fichier projet spécifie le framework cible par défaut quand vous publiez votre application.The <TargetFramework> setting of the project file specifies the default target framework when you publish your app. Vous pouvez choisir comme framework cible n’importe quel TFM (Target Framework Moniker) valide.You can change the target framework to any valid Target Framework Moniker (TFM). Par exemple, si votre projet utilise <TargetFramework>netcoreapp2.2</TargetFramework>, un binaire qui cible .NET Core 2.2 est créé.For example, if your project uses <TargetFramework>netcoreapp2.2</TargetFramework>, a binary that targets .NET Core 2.2 is created. Le TFM spécifié dans ce paramètre est la cible par défaut utilisée par la commande dotnet publish.The TFM specified in this setting is the default target used by the dotnet publish command.

Si vous souhaitez cibler plusieurs frameworks, vous pouvez affecter au paramètre <TargetFrameworks> plusieurs valeurs de TFM séparées par un point-virgule.If you want to target more than one framework, you can set the <TargetFrameworks> setting to more than one TFM value separated by a semicolon. Vous pouvez publier l’un des frameworks avec la commande dotnet publish -f <TFM>.You can publish one of the frameworks with the dotnet publish -f <TFM> command. Par exemple, si vous avez <TargetFrameworks>netcoreapp2.1;netcoreapp2.2</TargetFrameworks> et que vous exécutez dotnet publish -f netcoreapp2.1, un binaire qui cible .NET Core 2.1 est créé.For example, if you have <TargetFrameworks>netcoreapp2.1;netcoreapp2.2</TargetFrameworks> and run dotnet publish -f netcoreapp2.1, a binary that targets .NET Core 2.1 is created.

Le répertoire de sortie de la commande dotnet publish est ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/, sauf s’il est défini autrement.Unless otherwise set, the output directory of the dotnet publish command is ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Le mode BUILD-CONFIGURATION par défaut est Debug, sauf si vous le modifiez avec le paramètre -c.The default BUILD-CONFIGURATION mode is Debug unless changed with the -c parameter. Par exemple, dotnet publish -c Release -f netcoreapp2.1 publie dans myfolder/bin/Release/netcoreapp2.1/publish/.For example, dotnet publish -c Release -f netcoreapp2.1 publishes to myfolder/bin/Release/netcoreapp2.1/publish/.

Si vous utilisez le kit SDK .NET Core 3.0, le mode de publication par défaut pour les applications qui ciblent .NET Core version 2.1, 2.2 ou 3.0 est « Exécutable dépendant du framework ».If you use .NET Core SDK 3.0, the default publish mode for apps that target .NET Core versions 2.1, 2.2, or 3.0 is framework-dependent executable.

Si vous utilisez le kit SDK .NET Core 2.1, le mode de publication par défaut pour les applications qui ciblent .NET Core version 2.1 ou 2.2 est « Déploiement dépendant du framework ».If you use .NET Core SDK 2.1, the default publish mode for apps that target .NET Core versions 2.1, 2.2 is framework-dependent deployment.

Dépendances nativesNative dependencies

Si votre application a des dépendances natives, elle risque de ne pas fonctionner sur un autre système d’exploitation.If your app has native dependencies, it may not run on a different operating system. Par exemple, si votre application utilise l’API Windows native, elle ne s’exécutera pas sur macOS ou Linux.For example, if your app uses the native Windows API, it won't run on macOS or Linux. Vous devrez fournir du code propre à la plateforme et compiler un exécutable pour chaque plateforme.You would need to provide platform-specific code and compile an executable for each platform.

Sachez également que si une bibliothèque que vous avez référencée a une dépendance native, votre application risque de ne pas fonctionner sur toutes les plateformes.Consider also, if a library you referenced has a native dependency, your app may not run on every platform. Toutefois, il est possible qu’un package NuGet que vous référencez ait inclus des versions propres à la plateforme afin de gérer pour vous les dépendances natives requises.However, it's possible a NuGet package you're referencing has included platform-specific versions to handle the required native dependencies for you.

Lors de la distribution d’une application avec des dépendances natives, vous devrez peut-être utiliser le commutateur dotnet publish -r <RID> afin de spécifier la plateforme cible pour laquelle vous souhaitez publier.When distributing an app with native dependencies, you may need to use the dotnet publish -r <RID> switch to specify the target platform you want to publish for. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

Vous trouverez davantage d’informations sur les binaires propres à la plateforme dans les sections Exécutable dépendant du framework et Déploiement autonome.More information about platform-specific binaries is covered in the Framework-dependent executable and Self-contained deployment sections.

Exemple d’applicationSample app

Vous pouvez utiliser l’application ci-dessous pour explorer les commandes de publication.You can use either the following app to explore the publishing commands. L’application est créée en exécutant les commandes suivantes dans votre terminal :The app is created by running the following commands in your terminal:

mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle

Le fichier Program.cs ou Program.vb généré par le modèle de console doit être modifié comme suit :The Program.cs or Program.vb file that is generated by the console template needs to be changed to the following:

using System;

namespace apptest1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"));
        }
    }
}
Imports System

Module Program
    Sub Main(args As String())
        Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"))
    End Sub
End Module

Quand vous exécutez l’application (dotnet run), la sortie suivante s’affiche :When you run the app (dotnet run), the following output is displayed:

  _   _      _ _         __        __         _     _ _
 | | | | ___| | | ___    \ \      / /__  _ __| | __| | |
 | |_| |/ _ \ | |/ _ \    \ \ /\ / / _ \| '__| |/ _` | |
 |  _  |  __/ | | (_) |    \ V  V / (_) | |  | | (_| |_|
 |_| |_|\___|_|_|\___( )    \_/\_/ \___/|_|  |_|\__,_(_)
                     |/

Déploiement dépendant du frameworkFramework-dependent deployment

Pour l’interface CLI du kit SDK .NET Core 2.x, le déploiement dépendant du framework est le mode par défaut pour la commande dotnet publish de base.For the .NET Core SDK 2.x CLI, framework-dependent deployment (FDD) is the default mode for the basic dotnet publish command.

Quand vous publiez votre application en tant que déploiement dépendant du framework, un fichier <PROJECT-NAME>.dll est créé dans le dossier ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/.When you publish your app as an FDD, a <PROJECT-NAME>.dll file is created in the ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ folder. Pour exécuter votre application, accédez au dossier de sortie et utilisez la commande dotnet <PROJECT-NAME>.dll.To run your app, navigate to the output folder and use the dotnet <PROJECT-NAME>.dll command.

Votre application est configurée pour cibler une version spécifique de .NET Core.Your app is configured to target a specific version of .NET Core. Ce runtime .NET Core cible doit se trouver sur l’ordinateur où vous souhaitez exécuter votre application.That targeted .NET Core runtime is required to be on the machine where you want to run your app. Par exemple, si votre application cible .NET Core 2.2, le runtime .NET Core 2.2 doit être installé sur tout ordinateur sur lequel votre application s’exécute.For example, if your app targets .NET Core 2.2, any machine that your app runs on must have the .NET Core 2.2 runtime installed. Comme indiqué dans la section Principes de base de la publication, vous pouvez modifier votre fichier projet afin de changer le framework cible par défaut ou de cibler plusieurs frameworks.As stated in the Publishing basics section, you can edit your project file to change the default target framework or to target more than one framework.

La publication d’un déploiement dépendant du framework crée une application qui extrapole automatiquement vers le dernier correctif de sécurité .NET Core disponible sur le système qui exécute l’application.Publishing an FDD creates an app that automatically rolls-forward to the latest .NET Core security patch available on the system that runs the app. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .NET Core à utiliser.For more information on version binding at compile time, see Select the .NET Core version to use.

Exécutable dépendant du frameworkFramework-dependent executable

Pour l’interface CLI du kit SDK .NET Core 3.x, l’exécutable dépendant du framework est le mode par défaut pour la commande dotnet publish de base.For the .NET Core SDK 3.x CLI, framework-dependent executable (FDE) the default mode for the basic dotnet publish command. Vous n’avez pas besoin de spécifier d’autres paramètres tant que vous souhaitez cibler le système d’exploitation actuel.You don't need to specify any other parameters as long as you want to target the current operating system.

Dans ce mode, un hôte d’exécutable propre à la plateforme est créé pour héberger votre application multiplateforme.In this mode, a platform-specific executable host is created to host your cross-platform app. Ce mode est semblable au déploiement dépendant du framework, étant donné que celui-ci nécessite un ordinateur hôte sous la forme de la commande dotnet.This mode is similar to FDD as FDD requires a host in the form of the dotnet command. Le nom de fichier de l’exécutable hôte varie en fonction de la plateforme, et ressemble à <PROJECT-FILE>.exe.The host executable filename varies per platform, and is named something similar to <PROJECT-FILE>.exe. Vous pouvez exécuter cet exécutable directement au lieu d’appeler dotnet <PROJECT-FILE>.dll, qui constitue tout de même une manière acceptable d’exécuter l’application.You can run this executable directly instead of calling dotnet <PROJECT-FILE>.dll which is still an acceptable way to run the app.

Votre application est configurée pour cibler une version spécifique de .NET Core.Your app is configured to target a specific version of .NET Core. Ce runtime .NET Core cible doit se trouver sur l’ordinateur où vous souhaitez exécuter votre application.That targeted .NET Core runtime is required to be on the machine where you want to run your app. Par exemple, si votre application cible .NET Core 2.2, le runtime .NET Core 2.2 doit être installé sur tout ordinateur sur lequel votre application s’exécute.For example, if your app targets .NET Core 2.2, any machine that your app runs on must have the .NET Core 2.2 runtime installed. Comme indiqué dans la section Principes de base de la publication, vous pouvez modifier votre fichier projet afin de changer le framework cible par défaut ou de cibler plusieurs frameworks.As stated in the Publishing basics section, you can edit your project file to change the default target framework or to target more than one framework.

La publication d’un exécutable dépendant du framework crée une application qui extrapole automatiquement vers le dernier correctif de sécurité .NET Core disponible sur le système qui exécute l’application.Publishing an FDE creates an app that automatically rolls-forward to the latest .NET Core security patch available on the system that runs the app. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .NET Core à utiliser.For more information on version binding at compile time, see Select the .NET Core version to use.

Vous devez utiliser les commutateurs suivants avec la commande dotnet publish pour publier un exécutable dépendant du framework (sauf pour .NET Core 3.x quand vous ciblez la plateforme actuelle) :You must (except for .NET Core 3.x when you target the current platform) use the following switches with the dotnet publish command to publish an FDE:

  • -r <RID> Ce commutateur utilise un identificateur (RID) pour spécifier la plateforme cible.-r <RID> This switch uses an identifier (RID) to specify the target platform. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

  • --self-contained false Ce commutateur indique au kit SDK .NET Core qu’il doit créer un exécutable dépendant du framework.--self-contained false This switch tells the .NET Core SDK to create an executable as an FDE.

Quand vous utilisez le commutateur -r, le chemin du dossier de sortie devient : ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/Whenever you use the -r switch, the output folder path changes to: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Si vous utilisez l’exemple d’application, exécutez dotnet publish -f netcoreapp2.2 -r win10-x64 --self-contained false.If you use the example app, run dotnet publish -f netcoreapp2.2 -r win10-x64 --self-contained false. Cette commande crée l’exécutable suivant : ./bin/Debug/netcoreapp2.2/win10-x64/publish/apptest1.exeThis command creates the following executable: ./bin/Debug/netcoreapp2.2/win10-x64/publish/apptest1.exe

Notes

Vous pouvez réduire la taille totale de votre déploiement en activant le mode invariant de globalisation.You can reduce the total size of your deployment by enabling globalization invariant mode. Ce mode est utile pour les applications qui ne sont pas globalement compatibles et qui peuvent utiliser les conventions de mise en forme, les conventions de casse et la comparaison de chaînes, ainsi que l’ordre de tri de la culture invariante.This mode is useful for applications that are not globally aware and that can use the formatting conventions, casing conventions, and string comparison and sort order of the invariant culture. Pour plus d’informations sur le mode invariant de globalisation et sur la façon de l’activer, consultez .NET Core Globalization Invariant Mode.For more information about globalization invariant mode and how to enable it, see .NET Core Globalization Invariant Mode

Déploiement autonomeSelf-contained deployment

Quand vous publiez un déploiement autonome, le kit SDK .NET Core crée un exécutable propre à la plateforme.When you publish a self-contained deployment (SCD), the .NET Core SDK creates a platform-specific executable. La publication d’un déploiement autonome comprend tous les fichiers .NET Core nécessaires pour exécuter votre application, mais n’inclut pas les dépendances natives de .NET Core.Publishing an SCD includes all required .NET Core files to run your app but it doesn't include the native dependencies of .NET Core. Ces dépendances doivent être présentes sur le système avant l’exécution de l’application.These dependencies must be present on the system before the app runs.

La publication d’un déploiement autonome crée une application qui n’extrapole pas vers la dernière version de correctif de sécurité .NET Core disponible.Publishing an SCD creates an app that doesn't roll-forward to the latest available .NET Core security patch. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .NET Core à utiliser.For more information on version binding at compile time, see Select the .NET Core version to use.

Vous devez utiliser les commutateurs suivants avec la commande dotnet publish pour publier un déploiement autonome :You must use the following switches with the dotnet publish command to publish an SCD:

  • -r <RID> Ce commutateur utilise un identificateur (RID) pour spécifier la plateforme cible.-r <RID> This switch uses an identifier (RID) to specify the target platform. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

  • --self-contained true Ce commutateur indique au kit SDK .NET Core qu’il doit créer un exécutable sous forme de déploiement autonome.--self-contained true This switch tells the .NET Core SDK to create an executable as an SCD.

Notes

Vous pouvez réduire la taille totale de votre déploiement en activant le mode invariant de globalisation.You can reduce the total size of your deployment by enabling globalization invariant mode. Ce mode est utile pour les applications qui ne sont pas globalement compatibles et qui peuvent utiliser les conventions de mise en forme, les conventions de casse et la comparaison de chaînes, ainsi que l’ordre de tri de la culture invariante.This mode is useful for applications that are not globally aware and that can use the formatting conventions, casing conventions, and string comparison and sort order of the invariant culture. Pour plus d’informations sur le mode invariant de globalisation et sur la façon de l’activer, consultez .NET Core Globalization Invariant Mode.For more information about globalization invariant mode and how to enable it, see .NET Core Globalization Invariant Mode

Voir aussiSee also