Implantar aplicativos .NET Core com o Visual Studio

  • Artigo

Você pode implantar um aplicativo .NET Core como uma implantação dependente da estrutura, que inclui os binários do aplicativo, mas depende da presença do .NET Core no sistema de destino, ou como uma implantação independente, que inclui seus binários do aplicativo e do .NET Core. Para obter uma visão geral da implantação do aplicativo .NET Core, consulte Implantação do aplicativo .NET Core.

As seções a seguir mostram como usar o Microsoft Visual Studio para criar os seguintes tipos de implantações:

  • Implantação dependente da estrutura
  • Implantação dependente da estrutura com dependências de terceiros
  • Implantação autônoma
  • Implantação autônoma com dependências de terceiros

Para obter informações sobre como usar o Visual Studio para desenvolver aplicativos .NET Core, consulte Dependências e requisitos do .NET Core.

Implantação dependente da estrutura

Implantar uma implantação dependente da estrutura sem dependências de terceiros envolve simplesmente criar, testar e publicar o aplicativo. Um exemplo simples escrito em C# ilustra o processo.

  1. Crie o projeto.

    Selecione Ficheiro>Novo>Projeto. Na caixa de diálogo Novo Projeto, expanda as categorias de projeto do seu idioma (C# ou Visual Basic) no painel Tipos de projeto instalados, escolha .NET Core e selecione o modelo Aplicativo de Console (.NET Core) no painel central. Insira um nome de projeto, como "FDD", na caixa de texto Nome . Selecione o botão OK.

  2. Adicione o código-fonte do aplicativo.

    Abra o arquivo Program.cs ou Program.vb no editor e substitua o código gerado automaticamente pelo código a seguir. Ele solicita que o usuário insira texto e exibe as palavras individuais inseridas pelo usuário. Ele usa a expressão \w+ regular para separar as palavras no texto de entrada.

    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. Crie uma compilação de depuração do seu aplicativo.

    Selecione Build Build Solution (Criar>solução de compilação). Você também pode compilar e executar a compilação Debug do seu aplicativo selecionando Debug>Start Debugging.

  4. Implante seu aplicativo.

    Depois de depurar e testar o programa, crie os arquivos a serem implantados com seu aplicativo. Para publicar a partir do Visual Studio, faça o seguinte:

    1. Altere a configuração da solução de Debug para Release na barra de ferramentas para criar uma versão Release (em vez de Debug) do seu aplicativo.

    2. Clique com o botão direito do mouse no projeto (não na solução) no Gerenciador de Soluções e selecione Publicar.

    3. Na guia Publicar, selecione Publicar. Visual Studio grava os arquivos que compõem seu aplicativo para o sistema de arquivos local.

    4. A guia Publicar agora mostra um único perfil, FolderProfile. As definições de configuração do perfil são mostradas na seção Resumo da guia.

    Os arquivos resultantes são colocados em um diretório nomeado Publish no Windows e publish em sistemas Unix que está em um subdiretório do subdiretório .\bin\release\netcoreapp2.1 do seu projeto.

Junto com os arquivos do seu aplicativo, o processo de publicação emite um arquivo de banco de dados de programa (.pdb) que contém informações de depuração sobre seu aplicativo. O arquivo é útil principalmente para depurar exceções. Você pode optar por não empacotá-lo com os arquivos do seu aplicativo. No entanto, você deve salvá-lo caso queira depurar a compilação Release do seu aplicativo.

Implante o conjunto completo de arquivos do aplicativo da maneira que desejar. Por exemplo, você pode empacotá-los em um arquivo Zip, usar um comando simples copy ou implantá-los com qualquer pacote de instalação de sua escolha. Uma vez instalado, os usuários podem executar seu aplicativo usando o dotnet comando e fornecendo o nome do arquivo do aplicativo, como dotnet fdd.dll.

Além dos binários do aplicativo, o instalador também deve agrupar o instalador da estrutura compartilhada ou verificá-lo como pré-requisito como parte da instalação do aplicativo. A instalação da estrutura compartilhada requer acesso Administrador/raiz, uma vez que é em toda a máquina.

Implantação dependente da estrutura com dependências de terceiros

A implantação de uma implantação dependente da estrutura com uma ou mais dependências de terceiros requer que todas as dependências estejam disponíveis para seu projeto. As seguintes etapas adicionais são necessárias antes que você possa criar seu aplicativo:

  1. Use o Gerenciador de Pacotes NuGet para adicionar uma referência a um pacote NuGet ao seu projeto e, se o pacote ainda não estiver disponível em seu sistema, instale-o. Para abrir o gerenciador de pacotes, selecione Ferramentas>Gerenciador de Pacotes>NuGet Gerenciar Pacotes NuGet para Solução.

  2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no seu sistema e, se não estiverem, instale-as. A guia Instalado lista os pacotes NuGet instalados no seu sistema. Se Newtonsoft.Json não estiver listado lá, selecione a guia Procurar e digite "Newtonsoft.Json" na caixa de pesquisa. Selecione Newtonsoft.Json e, no painel direito, selecione seu projeto antes de selecionar Instalar.

  3. Se Newtonsoft.Json já estiver instalado em seu sistema, adicione-o ao seu projeto selecionando seu projeto no painel direito da guia Gerenciar pacotes para solução .

Uma implantação dependente da estrutura com dependências de terceiros é tão portátil quanto suas dependências de terceiros. Por exemplo, se uma biblioteca de terceiros suportar apenas macOS, a aplicação não é portátil para sistemas Windows. Isso acontece se a própria dependência de terceiros depender de código nativo. Um bom exemplo disso é o servidor Kestrel, que requer uma dependência nativa do libuv. Quando um FDD é criado para um aplicativo com esse tipo de dependência de terceiros, a saída publicada contém uma pasta para cada Identificador de Tempo de Execução (RID) que a dependência nativa suporta (e que existe em seu pacote NuGet).

Implantação autônoma sem dependências de terceiros

A implantação de uma implantação autônoma sem dependências de terceiros envolve a criação do projeto, a modificação do arquivo csproj, a criação, o teste e a publicação do aplicativo. Um exemplo simples escrito em C# ilustra o processo. Você começa criando, codificando e testando seu projeto da mesma forma que faria com uma implantação dependente da estrutura:

  1. Crie o projeto.

    Selecione Ficheiro>Novo>Projeto. Na caixa de diálogo Novo Projeto, expanda as categorias de projeto do seu idioma (C# ou Visual Basic) no painel Tipos de projeto instalados, escolha .NET Core e selecione o modelo Aplicativo de Console (.NET Core) no painel central. Digite um nome de projeto, como "SCD", na caixa de texto Nome e selecione o botão OK .

  2. Adicione o código-fonte do aplicativo.

    Abra o arquivo Program.cs ou Program.vb no editor e substitua o código gerado automaticamente pelo código a seguir. Ele solicita que o usuário insira texto e exibe as palavras individuais inseridas pelo usuário. Ele usa a expressão \w+ regular para separar as palavras no texto de entrada.

    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. Determine se você deseja usar o modo invariante de globalização.

    Particularmente se seu aplicativo tem como alvo o Linux, você pode reduzir o tamanho total de sua implantação aproveitando o modo invariante de globalização. O modo invariante de globalização é útil para aplicativos que não são globalmente conscientes e que podem usar as convenções de formatação, convenções de caixa e comparação de cadeia de caracteres e ordem de classificação da cultura invariante.

    Para habilitar o modo invariante, clique com o botão direito do mouse em seu projeto (não na solução) no Gerenciador de Soluções e selecione Editar SCD.csproj ou Editar SCD.vbproj. Em seguida, adicione as seguintes linhas realçadas ao arquivo:

    <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. Crie uma compilação de depuração do seu aplicativo.

    Selecione Build Build Solution (Criar>solução de compilação). Você também pode compilar e executar a compilação Debug do seu aplicativo selecionando Debug>Start Debugging. Esta etapa de depuração permite identificar problemas com seu aplicativo quando ele está sendo executado em sua plataforma host. Você ainda terá que testá-lo em cada uma das suas plataformas de destino.

    Se você habilitou o modo invariante de globalização, certifique-se de testar se a ausência de dados sensíveis à cultura é adequada para seu aplicativo.

Depois de concluir a depuração, você pode publicar sua implantação independente:

Depois de depurar e testar o programa, crie os arquivos a serem implantados com seu aplicativo para cada plataforma direcionada.

Para publicar seu aplicativo do Visual Studio, faça o seguinte:

  1. Defina as plataformas que seu aplicativo segmentará.

    1. Clique com o botão direito do mouse em seu projeto (não na solução) no Gerenciador de Soluções e selecione Editar SCD.csproj.

    2. Crie uma <RuntimeIdentifiers> tag na <PropertyGroup> seção do arquivo csproj que define as plataformas de destino do seu aplicativo e especifique o identificador de tempo de execução (RID) de cada plataforma que você segmenta. Você também precisa adicionar um ponto-e-vírgula para separar os RIDs. Consulte Catálogo de identificadores de tempo de execução para obter uma lista de identificadores de tempo de execução.

    Por exemplo, o exemplo a seguir indica que o aplicativo é executado em sistemas operacionais Windows de 64 bits e no sistema operacional OS X de 64 bits.

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

    O <RuntimeIdentifiers> elemento pode entrar em qualquer um <PropertyGroup> que você tenha em seu arquivo csproj . Um arquivo csproj de exemplo completo aparece mais adiante nesta seção.

  2. Publique seu aplicativo.

    Depois de depurar e testar o programa, crie os arquivos a serem implantados com seu aplicativo para cada plataforma direcionada.

    Para publicar seu aplicativo do Visual Studio, faça o seguinte:

    1. Altere a configuração da solução de Debug para Release na barra de ferramentas para criar uma versão Release (em vez de Debug) do seu aplicativo.

    2. Clique com o botão direito do mouse no projeto (não na solução) no Gerenciador de Soluções e selecione Publicar.

    3. Na guia Publicar, selecione Publicar. Visual Studio grava os arquivos que compõem seu aplicativo para o sistema de arquivos local.

    4. A guia Publicar agora mostra um único perfil, FolderProfile. As definições de configuração do perfil são mostradas na seção Resumo da guia. O Target Runtime identifica qual tempo de execução foi publicado e o Target Location identifica onde os arquivos para a implantação independente foram gravados.

    5. Por padrão, o Visual Studio grava todos os arquivos publicados em um único diretório. Por conveniência, é melhor criar perfis separados para cada tempo de execução de destino e colocar os arquivos publicados em um diretório específico da plataforma. Isso envolve a criação de um perfil de publicação separado para cada plataforma de destino. Então, agora reconstrua o aplicativo para cada plataforma fazendo o seguinte:

      1. Selecione Criar novo perfil na caixa de diálogo Publicar .

      2. Na caixa de diálogo Escolha um destino de publicação, altere a opção Escolha um local de pasta para bin\Release\PublishOutput\win-x64. Selecione OK.

      3. Selecione o novo perfil (FolderProfile1) na lista de perfis e certifique-se de que o Target Runtime é win-x64. Se não estiver, selecione Configurações. Na caixa de diálogo Configurações de perfil, altere o Tempo de Execução de Destino para win-x64 e selecione Salvar. Caso contrário, selecione Cancelar.

      4. Selecione Publicar para publicar seu aplicativo para plataformas Windows 10 de 64 bits.

      5. Siga os passos anteriores novamente para criar um perfil para a osx-x64 plataforma. O Local de Destino é bin\Release\PublishOutput\osx-x64 e o Target Runtime é osx-x64. O nome que o Visual Studio atribui a esse perfil é FolderProfile2.

    Cada local de destino contém o conjunto completo de arquivos (os arquivos do aplicativo e todos os arquivos .NET Core) necessários para iniciar o aplicativo.

Junto com os arquivos do seu aplicativo, o processo de publicação emite um arquivo de banco de dados de programa (.pdb) que contém informações de depuração sobre seu aplicativo. O arquivo é útil principalmente para depurar exceções. Você pode optar por não empacotá-lo com os arquivos do seu aplicativo. No entanto, você deve salvá-lo caso queira depurar a compilação Release do seu aplicativo.

Implante os arquivos publicados da maneira que desejar. Por exemplo, você pode empacotá-los em um arquivo Zip, usar um comando simples copy ou implantá-los com qualquer pacote de instalação de sua escolha.

A seguir está o arquivo csproj completo para este projeto.

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

Implantação autônoma com dependências de terceiros

A implantação de uma implantação autônoma com uma ou mais dependências de terceiros envolve a adição das dependências. As seguintes etapas adicionais são necessárias antes que você possa criar seu aplicativo:

  1. Use o Gerenciador de Pacotes NuGet para adicionar uma referência a um pacote NuGet ao seu projeto e, se o pacote ainda não estiver disponível em seu sistema, instale-o. Para abrir o gerenciador de pacotes, selecione Ferramentas>Gerenciador de Pacotes>NuGet Gerenciar Pacotes NuGet para Solução.

  2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no seu sistema e, se não estiverem, instale-as. A guia Instalado lista os pacotes NuGet instalados no seu sistema. Se Newtonsoft.Json não estiver listado lá, selecione a guia Procurar e digite "Newtonsoft.Json" na caixa de pesquisa. Selecione Newtonsoft.Json e, no painel direito, selecione seu projeto antes de selecionar Instalar.

  3. Se Newtonsoft.Json já estiver instalado em seu sistema, adicione-o ao seu projeto selecionando seu projeto no painel direito da guia Gerenciar pacotes para solução .

A seguir está o arquivo csproj completo para este projeto:

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

Quando você implanta seu aplicativo, todas as dependências de terceiros usadas em seu aplicativo também estão contidas nos arquivos do aplicativo. Bibliotecas de terceiros não são necessárias no sistema no qual o aplicativo está sendo executado.

Você só pode implantar uma implantação independente com uma biblioteca de terceiros em plataformas suportadas por essa biblioteca. Isso é semelhante a ter dependências de terceiros com dependências nativas em sua implantação dependente da estrutura, onde as dependências nativas não existirão na plataforma de destino, a menos que tenham sido instaladas anteriormente lá.

Consulte também