Déployer des applications .NET Core avec Visual Studio

  • Article

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>net6.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 :

Après avoir débogué et testé le programme, créez les fichiers à déployer avec votre application pour chaque plateforme ciblée.

Pour publier votre application à partir de Visual Studio, effectuez les étapes suivantes :

  1. Définissez les plateformes ciblées par votre application.

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

    2. Créez une balise <RuntimeIdentifiers> dans la section <PropertyGroup> de votre fichier csproj qui définit les plateformes ciblées par votre application, et spécifiez l’identificateur de runtime de chaque plateforme ciblée. Vous devez également ajouter un point-virgule pour séparer les identificateurs de runtime. Consultez Catalogue des identificateurs de runtime pour obtenir une liste des identificateurs de runtime.

    Par exemple, l’exemple suivant indique que l’application s’exécute sur les systèmes d’exploitation Windows 64 bits et le système d’exploitation OS X 64 bits.

    <PropertyGroup>
   <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
</PropertyGroup>

    L’élément <RuntimeIdentifiers> peut être placé dans n’importe quelle section <PropertyGroup> de votre fichier csproj. Un exemple complet de fichier csproj figure plus loin dans cette section.

  2. Publiez votre application.

    Après avoir débogué et testé le programme, créez les fichiers à déployer avec votre application pour chaque plateforme ciblée.

    Pour publier votre application à 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. Le Runtime cible identifie le runtime qui a été publié tandis que l’Emplacement cible identifie l’emplacement où les fichiers du déploiement autonome ont été écrits.

    5. Par défaut, Visual Studio écrit tous les fichiers publiés dans un répertoire unique. Pour des raisons pratiques, il est préférable de créer des profils séparés pour chaque runtime cible et de placer les fichiers publiés dans un répertoire spécifique à la plateforme. Vous devez donc créer un profil de publication distinct pour chaque plateforme cible. À présent, effectuez les étapes suivantes pour regénérer l’application pour chaque plateforme :

      1. Sélectionnez Créer un profil dans la boîte de dialogue Publier.

      2. Dans la boîte de dialogue Choisir une cible de publication, modifiez l’emplacement Choisir un dossier en bin\Release\PublishOutput\win-x64. Cliquez sur OK.

      3. Sélectionnez le nouveau profil (FolderProfile1) dans la liste des profils et vérifiez que le Runtime cible est win-x64. Si ce n’est pas le cas, sélectionnez Paramètres. Dans la boîte de dialogue Paramètres du profil, définissez Runtime cible avec la valeur win-x64 et sélectionnez Enregistrer. Sinon, sélectionnez Annuler.

      4. Sélectionnez Publier pour publier votre application pour des plateformes Windows 10 64 bits.

      5. Suivez les étapes précédentes pour créer un profil pour la plateforme osx-x64. L’emplacement cible est bin\Release\PublishOutput\osx-x64, et le Runtime cible est osx-x64. Le nom attribué par Visual Studio à ce profil est FolderProfile2.

    Chaque emplacement cible contient l’ensemble complet des fichiers nécessaires pour lancer votre application, à savoir les fichiers de votre application et tous les fichiers .NET Core.

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 les fichiers publiés 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.

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>
</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>

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