Déployer des applications .NET Core avec Visual Studio

Pour déployer une application .NET Core, vous pouvez soit effectuer un déploiement dépendant du framework (qui inclut vos binaires d’application, mais qui dépend de la présence de .NET Core sur le système cible), soit effectuer un déploiement autonome (qui inclut votre application et les binaires .NET Core). Pour obtenir une vue d’ensemble du déploiement des applications .NET Core, consultez Déploiement d’applications .NET Core.

Les sections suivantes montrent comment utiliser Microsoft Visual Studio pour créer les genres de déploiements suivants :

• Déploiement dépendant du framework
• Déploiement dépendant du framework avec des dépendances tierces
• Déploiement autonome
• Déploiement autonome avec des dépendances tierces

Pour plus d’informations sur l’utilisation de Visual Studio pour développer des applications .NET Core, consultez Dépendances et exigences .NET Core.

Déploiement dépendant du framework

Le déploiement d’un déploiement dépendant du framework sans dépendances tierces implique simplement la génération, le test et la publication de l’application. Un exemple simple écrit en C# illustre le processus.

1. Créez le projet.

   Sélectionnez Fichier>Nouveau>Projet. Dans la boîte de dialogue Nouveau projet, développez les catégories de projet de votre langage (C# ou Visual Basic) au sein du volet des types de projet Installé, choisissez .NET Core, puis sélectionnez le modèle Application console (.NET Core) dans le volet central. Entrez un nom de projet, tel que « FDD », dans la zone de texte Nom. Cliquez sur le bouton OK.

2. Ajoutez le code source de l’application.

   Ouvrez le fichier Program.cs ou Program.vb dans l’éditeur, puis remplacez le code généré automatiquement par le code suivant. Il invite l’utilisateur à entrer du texte et affiche les différents mots entrés. Il utilise l’expression régulière \w+ pour séparer les mots dans le texte d’entrée.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Créez une build Debug de votre application.

   Sélectionnez Générer>Générer la solution. Vous pouvez également compiler et exécuter la build Debug de votre application en sélectionnant Déboguer>Démarrer le débogage.

4. Déployez votre application.

   Après avoir débogué et testé le programme, créez les fichiers à déployer avec votre application. Pour publier à partir de Visual Studio, effectuez les étapes suivantes :

   1. Remplacez la configuration de solution Debug par Release dans la barre d’outils pour générer une build Release (et non une build Debug) de votre application.

   2. Cliquez avec le bouton droit sur le projet (pas la solution) dans l’Explorateur de solutions, puis sélectionnez Publier.

   3. Sous l’onglet Publier, sélectionnez Publier. Visual Studio écrit les fichiers qui composent votre application dans le système de fichiers local.

   4. L’onglet Publier affiche maintenant un seul profil, FolderProfile. Les paramètres de configuration du profil sont affichés dans la section Résumé de l’onglet.

   Les fichiers résultants sont placés dans un répertoire nommé Publish sur Windows (publish sur les systèmes Unix), qui se trouve dans un sous-répertoire du sous-répertoire .\bin\release\netcoreapp2.1 de votre projet.

En même temps que les fichiers de votre application, le processus de publication produit un fichier de base de données du programme (.pdb) qui contient des informations de débogage sur votre application. Le fichier est surtout utile pour le débogage d’exceptions. Vous pouvez choisir de ne pas l’empaqueter avec les fichiers de votre application. Vous devez toutefois l’enregistrer au cas où vous souhaiteriez déboguer la build Release de votre application.

Déployez l’ensemble complet des fichiers d’application de la façon qui vous convient. Par exemple, vous pouvez les empaqueter dans un fichier Zip, utiliser une simple commande copy ou les déployer avec n’importe quel package d’installation de votre choix. Une fois l’installation terminée, les utilisateurs peuvent exécuter votre application en utilisant la commande dotnet suivie du nom de l’application. Par exemple : dotnet fdd.dll.

Outre les binaires de l’application, votre programme d’installation doit également regrouper le programme d’installation du framework partagé ou vérifier qu’il est bien installé comme prérequis de l’installation de l’application. L’installation du framework partagé nécessite un accès Administrateur/root car il est à l’échelle de la machine.

Déploiement dépendant du framework avec des dépendances tierces

Pour exécuter un déploiement dépendant du framework avec une ou plusieurs dépendances tierces, ces dépendances doivent être accessibles à votre projet. Avant de pouvoir générer votre application, vous devez effectuer les étapes suivantes :

1. Utilisez le Gestionnaire de package NuGet pour ajouter à votre projet une référence à un package NuGet et installer le package s’il n’est pas disponible sur votre système. Pour ouvrir le Gestionnaire de package, sélectionnez Outils>Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.

2. Vérifiez que vos dépendances tierces (par exemple, Newtonsoft.Json) sont installées sur votre système et, si ce n’est pas le cas, installez-les. L’onglet Installé répertorie les packages NuGet installés sur votre système. Si Newtonsoft.Json n’est pas répertorié, sélectionnez l’onglet Parcourir et entrez « Newtonsoft.Json » dans la zone de recherche. Sélectionnez Newtonsoft.Json et, dans le volet droit, choisissez votre projet avant de sélectionner Installer.

3. Si Newtonsoft.Json est déjà installé sur votre système, ajoutez-le à votre projet en sélectionnant votre projet dans le volet droit de l’onglet Gérer les packages de la solution.

Un déploiement dépendant du framework avec des dépendances tierces n’est portable que dans la mesure de la portabilité de ses dépendances tierces. Par exemple, si une bibliothèque tierce prend uniquement en charge macOS, l’application n’est pas portable sur des systèmes Windows. Cela se produit si la dépendance tierce elle-même dépend du code natif. Un serveur Kestrel constitue un bon exemple, car il nécessite une dépendance native à libuv. Quand un déploiement dépendant du framework est créé pour une application avec ce type de dépendance tierce, le résultat publié contient un dossier pour chaque identificateur de runtime pris en charge par la dépendance native (et qui existe dans le package NuGet).

Déploiement autonome sans dépendances tierces

L’exécution d’un déploiement autonome sans aucune dépendance tierce implique la création du projet, la modification du fichier csproj, la génération, le test et la publication de l’application. Un exemple simple écrit en C# illustre le processus. Commencez par créer, coder et tester votre projet comme pour un déploiement dépendant du framework :

1. Créez le projet.

   Sélectionnez Fichier>Nouveau>Projet. Dans la boîte de dialogue Nouveau projet, développez les catégories de projet de votre langage (C# ou Visual Basic) au sein du volet des types de projet Installé, choisissez .NET Core, puis sélectionnez le modèle Application console (.NET Core) dans le volet central. Entrez un nom de projet, tel que « SCD », dans la zone de texte Nom, puis sélectionnez le bouton OK.

2. Ajoutez le code source de l’application.

   Ouvrez le fichier Program.cs ou Program.vb dans votre éditeur, puis remplacez le code généré automatiquement par le code suivant. Il invite l’utilisateur à entrer du texte et affiche les différents mots entrés. Il utilise l’expression régulière \w+ pour séparer les mots dans le texte d’entrée.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Déterminez si vous souhaitez utiliser le mode invariant de globalisation.

   En particulier, si votre application cible Linux, vous pouvez réduire la taille totale de votre déploiement en tirant parti du mode invariant de globalisation. Le mode invariant de globalisation 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.

   Pour activer le mode invariant, cliquez avec le bouton droit sur le projet (pas la solution) dans l’Explorateur de solutions, puis sélectionnez Modifier SCD.csproj ou Modifier SCD.vbproj. Ajoutez ensuite les lignes en surbrillance suivantes au fichier :

   <Project Sdk="Microsoft.NET.Sdk">
   
     <PropertyGroup>
       <TargetFramework>net8.0</TargetFramework>
       <Nullable>enable</Nullable>
     </PropertyGroup>
   
     <ItemGroup>
       <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
     </ItemGroup> 
   
   </Project>
   

4. Créez une build Debug de votre application.

   Sélectionnez Générer>Générer la solution. Vous pouvez également compiler et exécuter la build Debug de votre application en sélectionnant Déboguer>Démarrer le débogage. Cette étape de débogage vous permet d’identifier les problèmes de votre application quand elle s’exécute sur la plateforme hôte. Vous devez tout de même la tester sur chacune des plateformes cibles.

   Si vous avez activé le mode invariant de globalisation, vérifiez si l’absence de données relatives à la culture convient à votre application.

Une fois le débogage effectué, vous pouvez publier votre déploiement autonome :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
</Project>

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <PublishProtocol>FileSystem</PublishProtocol>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <PublishDir>bin\Release\netcoreapp2.1\publish\linux</PublishDir>
    <RuntimeIdentifier>win-x86</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <_IsPortable>false</_IsPortable>
  </PropertyGroup>
</Project>

Déploiement autonome avec des dépendances tierces

L’exécution d’un déploiement autonome avec une ou plusieurs dépendances tierces implique l’ajout des dépendances. Avant de pouvoir générer votre application, vous devez effectuer les étapes suivantes :

1. Utilisez le Gestionnaire de package NuGet pour ajouter à votre projet une référence à un package NuGet et installer le package s’il n’est pas disponible sur votre système. Pour ouvrir le Gestionnaire de package, sélectionnez Outils>Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.

2. Vérifiez que vos dépendances tierces (par exemple, Newtonsoft.Json) sont installées sur votre système et, si ce n’est pas le cas, installez-les. L’onglet Installé répertorie les packages NuGet installés sur votre système. Si Newtonsoft.Json n’est pas répertorié, sélectionnez l’onglet Parcourir et entrez « Newtonsoft.Json » dans la zone de recherche. Sélectionnez Newtonsoft.Json et, dans le volet droit, choisissez votre projet avant de sélectionner Installer.

3. Si Newtonsoft.Json est déjà installé sur votre système, ajoutez-le à votre projet en sélectionnant votre projet dans le volet droit de l’onglet Gérer les packages de la solution.

Voici le fichier csproj complet pour ce projet :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Quand vous déployez votre application, toutes les dépendances tierces utilisées dans votre application sont également incluses avec vos fichiers d’application. Il n’est pas nécessaire que les bibliothèques tierces soient déjà présentes sur le système sur lequel l’application s’exécute.

Vous pouvez déployer un déploiement autonome avec une bibliothèque tierce seulement sur des plateformes prises en charge par cette bibliothèque. Cela revient à avoir des dépendances tierces avec des dépendances natives dans votre déploiement dépendant du framework, où les dépendances natives n’existent pas sur la plateforme cible, sauf si elles y ont été installées précédemment.

Voir aussi

• Déploiement d’applications .NET Core
• Catalogue d’identificateurs de runtime (RID) .NET Core