Visão geral da publicação de aplicativos .NET

Este artigo explica as diferentes maneiras de publicar um aplicativo .NET. Ele aborda os modos de publicação, como produzir executáveis e binários entre plataformas e o impacto de cada abordagem em ambientes de implantação e tempo de execução. Você pode publicar aplicativos .NET usando a CLI do .NET ou o Visual Studio.

Para obter um breve tutorial sobre publicação, consulte Tutorial: Publicar um aplicativo de console .NET usando o Visual Studio Code.

Para obter um breve tutorial sobre publicação, consulte Tutorial: Publicar um aplicativo de console .NET usando o Visual Studio.

O que é publicar

Publicar um aplicativo .NET significa compilar o código-fonte para criar um executável ou binário, juntamente com suas dependências e arquivos relacionados, para distribuição. Após a publicação, você implanta o aplicativo em um servidor, plataforma de distribuição, contêiner ou ambiente de nuvem. O processo de publicação prepara um aplicativo para implantação e uso fora de um ambiente de desenvolvimento.

Modos de publicação

Há duas maneiras principais de publicar um aplicativo. Alguns fatores que influenciam essa decisão incluem se o ambiente de implantação tem o .NET Runtime apropriado instalado e se você precisa de recursos de compilação específicos que exigem a agregação do tempo de execução com seu aplicativo. Os dois modos de publicação são:

• Publicar autossuficiente
  Esse modo produz uma pasta de publicação que inclui um executável específico da plataforma usado para iniciar o aplicativo, um binário compilado contendo o código do aplicativo, quaisquer dependências do aplicativo e o tempo de execução do .NET necessário para executar o aplicativo. O ambiente que executa o aplicativo não precisa ter o tempo de execução do .NET pré-instalado.

• Publicar dependente da estrutura
  Esse modo produz uma pasta de publicação que inclui um executável opcional específico da plataforma usado para iniciar o aplicativo, um binário compilado contendo o código do aplicativo e quaisquer dependências do aplicativo. O ambiente que executa o aplicativo deve ter uma versão do tempo de execução do .NET instalada que o aplicativo possa usar.

Importante

Você especifica a plataforma de destino com um identificador de tempo de execução (RID). Para mais informações sobre RIDs, veja Catálogo de RID do .NET.

Noções básicas de publicação

A <TargetFramework> configuração do arquivo de projeto especifica a estrutura de destino padrão quando você publica seu aplicativo. Você pode alterar a estrutura de destino para qualquer Target Framework Moniker (TFM) válido. Por exemplo, se o seu projeto usa <TargetFramework>net9.0</TargetFramework>, um binário destinado ao .NET 9 é criado.

Se quiser direcionar mais de uma estrutura, você pode definir a <TargetFrameworks> configuração para vários valores de TFM, separados por ponto-e-vírgula. Quando você cria seu aplicativo, ele é criado para cada estrutura de destino definida pelo seu projeto. No entanto, ao publicar seu aplicativo, você deve especificar a estrutura de destino:

O modo de configuração de compilação padrão é Release, a menos que seja alterado com o -c parâmetro.

dotnet publish -c Release -f net9.0

O diretório de saída padrão do dotnet publish comando é ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Por exemplo, dotnet publish -c Release -f net9.0 publica em ./bin/Release/net9.0/publish/. No entanto, você pode optar por um caminho de saída simplificado e estrutura de pastas para todas as saídas de compilação. Para obter mais informações, consulte Layout de saída de artefatos.

No Visual Studio, crie perfis de publicação separados para cada estrutura de destino.

Binários portáteis

Ao publicar um aplicativo .NET, você pode direcionar uma plataforma específica ou criar um binário portátil. Por padrão, mesmo ao criar um binário portátil, o .NET publica um executável específico da plataforma ("apphost") ao lado da DLL portátil, a menos que você desabilite explicitamente esse comportamento.

O executável específico da plataforma é criado devido à UseAppHost propriedade, cujo padrão é true. Para publicar apenas a DLL portátil sem o executável específico da plataforma, defina UseAppHost como false na linha de comando (-p:UseAppHost=false) ou como uma propriedade do projeto.

O benefício de segmentar uma plataforma específica é que ela pode lidar com dependências nativas que seu aplicativo pode exigir, garantindo a compatibilidade com os requisitos específicos da plataforma de destino.

Dependências nativas

Se o seu aplicativo tiver dependências nativas, ele pode não ser executado em um sistema operacional diferente se publicado como um binário portátil. Por exemplo, os aplicativos que dependem da API do Windows não são executados nativamente no macOS ou Linux. Você precisaria fornecer código específico da plataforma e compilar um executável para cada plataforma.

Considere também que, se uma biblioteca referenciada fornecer dependências específicas da plataforma, seu aplicativo pode não ser executado em todas as plataformas. No entanto, quando você publica e direciona uma plataforma específica, as dependências específicas da plataforma de um pacote NuGet são copiadas para a pasta de publicação.

Para garantir que seu aplicativo seja publicado com suas dependências nativas, publique para uma plataforma específica:

dotnet publish -c Release -r <RID>

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).
6. Selecione Salvar e, em seguida, Publicar.

Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

Referência rápida

A tabela a seguir fornece exemplos rápidos de como publicar seu aplicativo.

Modo de publicação	Comando
Implantação dependente da estrutura	dotnet publish -c Release [-r <RID>]
Implantação dependente da estrutura (DLL)	dotnet publish -c Release -p:UseAppHost=false
Implantação autônoma	dotnet publish -c Release [-r <RID>] --self-contained true
Implantação de arquivo único	dotnet publish -c Release [-r <RID>] -p:PublishSingleFile=true
Implantação de AOT nativa	dotnet publish -c Release [-r <RID>] -p:PublishAot=true
Implantação do ReadyToRun	dotnet publish -c Release [-r <RID>] -p:PublishReadyToRun=true
Implantação de contêiner	dotnet publish -c Release [-r <RID>] -t:PublishContainer

Implantação dependente da estrutura

A implantação dependente da estrutura é o modo padrão quando você publica a partir da CLI ou do Visual Studio. Nesse modo, é criado um executável específico da plataforma que pode ser usado para iniciar seu aplicativo. O executável específico da plataforma é nomeado algo semelhante ao myapp.exe Windows ou apenas myapp em outras plataformas.

Seu aplicativo está configurado para direcionar uma versão específica do .NET. Esse tempo de execução .NET direcionado é necessário para estar no ambiente em que seu aplicativo é executado. Por exemplo, se seu aplicativo tem como destino o .NET 9, qualquer ambiente em que seu aplicativo seja executado deve ter o tempo de execução do .NET 9 instalado.

A publicação de uma implantação dependente da estrutura cria um aplicativo que avança automaticamente para o patch de segurança .NET mais recente disponível no ambiente que executa o aplicativo. Para obter mais informações sobre vinculação de versão em tempo de compilação, consulte Selecione a versão .NET a ser usada.

Vantagens

• Pequena implantação: somente o aplicativo e suas dependências são distribuídos. O ambiente onde o aplicativo é executado já deve ter o tempo de execução do .NET instalado.
• Multiplataforma: O aplicativo e qualquer arquivo . A biblioteca baseada em NET é executada em outros sistemas operacionais.
• Usa o tempo de execução corrigido mais recente: o aplicativo usa o tempo de execução mais recente instalado no ambiente.

Desvantagens

• Requer a pré-instalação do tempo de execução: o aplicativo só pode ser executado se a versão do .NET a que se destina já estiver instalada no ambiente.
• O .NET pode mudar: o ambiente onde o aplicativo é executado pode usar um tempo de execução .NET mais recente, o que pode alterar o comportamento do aplicativo.

Iniciar aplicações dependentes do framework

Há duas maneiras de executar aplicativos dependentes da estrutura: por meio do executável específico da plataforma ("apphost") e via dotnet myapp.dll. Você pode executar o executável apphost diretamente em vez de chamar dotnet myapp.dll, que ainda é uma maneira aceitável de executar o aplicativo. Sempre que possível, recomenda-se usar o apphost. Há uma série de vantagens em usar o apphost:

• Os executáveis aparecem como executáveis de plataforma nativa padrão.
• Os nomes executáveis são preservados nos nomes dos processos, o que significa que os aplicativos podem ser facilmente reconhecidos com base em seus nomes.
• Como o apphost é um binário nativo, ativos nativos como manifestos podem ser anexados a eles.
• O Apphost tem disponíveis mitigações de segurança de baixo nível aplicadas por padrão que o tornam mais seguro. Por exemplo, a pilha de sombras da tecnologia de imposição de fluxo de controle (CET) está ativada por padrão a partir do .NET 9. As mitigações aplicadas a dotnet são o menor denominador comum de todos os ambientes de execução suportados.

Publicar

dotnet publish -c Release [-r <RID>]

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

Ou explicitamente:

dotnet publish -c Release [-r <RID>] --self-contained false

• --self-contained false

  Essa opção informa explicitamente ao SDK do .NET para criar uma implantação dependente da estrutura.

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Modo de Implantação como dependente da estrutura (esse é o padrão).
6. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).
7. Selecione Salvar e, em seguida, Publicar.

Configurar o comportamento de pesquisa de instalação do .NET

Por defeito, o apphost descobre e utiliza um ambiente de execução .NET instalado globalmente, com locais de instalação a variar conforme a plataforma. Para obter mais informações sobre a descoberta de tempo de execução e locais de instalação, consulte Solucionar problemas de falhas de inicialização de aplicativos.

O caminho de tempo de execução do .NET também pode ser personalizado por execução. A DOTNET_ROOT variável de ambiente pode ser usada para apontar para o local personalizado. Para obter mais informações sobre todas as DOTNET_ROOT opções de configuração, consulte Variáveis de ambiente .NET.

Em geral, a melhor prática de utilização DOTNET_ROOT consiste em:

1. Limpe DOTNET_ROOT as variáveis de ambiente primeiro, ou seja, todas as variáveis de ambiente que começam com o texto DOTNET_ROOT.
2. Defina DOTNET_ROOT, e somente DOTNET_ROOT, para o caminho de destino.
3. Execute o "apphost" alvo.

No .NET 9 e versões posteriores, você pode configurar os caminhos de pesquisa de instalação do .NET do executável publicado por meio das AppHostDotNetSearch propriedades e AppHostRelativeDotNet .

AppHostDotNetSearch permite especificar um ou mais locais onde o executável procurará uma instalação .NET:

• AppLocal: pasta do executável do aplicativo
• AppRelative: caminho relativo ao executável do aplicativo
• EnvironmentVariable: valor das variáveis de DOTNET_ROOT[_<arch>] ambiente
• Global: locais de instalação globais registrados e padrão

AppHostRelativeDotNet especifica o caminho relativo ao executável que será pesquisado quando AppHostDotNetSearch contiver AppRelative.

Para obter mais informações, consulte AppHostDotNetSearch, AppHostRelativeDotNete instalar opções de localização no apphost.

Implantação de DLL entre plataformas

Como alternativa, você pode publicar seu aplicativo como uma DLL de plataforma cruzada sem um executável específico da plataforma. Nesse modo, um myapp.dll arquivo é criado na pasta de saída de publicação. Para executar seu aplicativo, navegue até a pasta de saída e use o dotnet myapp.dll comando.

Para publicar como uma DLL multiplataforma:

dotnet publish -c Release -p:UseAppHost=false

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -p:UseAppHost=false

  Esta propriedade desativa a criação de um executável específico da plataforma, produzindo apenas a DLL portátil.

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Modo de Implantação como dependente da Estrutura.
6. Desmarque Produzir arquivo único.
7. Defina o Target Runtime como Portable (ou deixe em branco).
8. Selecione Salvar e, em seguida, Publicar.

Implantação autônoma

Quando você publica uma implantação independente (SCD), o processo de publicação cria um executável específico da plataforma. A publicação de um SCD inclui todos os arquivos .NET necessários para executar seu aplicativo, mas não inclui as dependências nativas do .NET. Essas dependências devem estar presentes no ambiente antes que o aplicativo seja executado.

A publicação de um SCD cria um aplicativo que não avança para o patch de segurança .NET mais recente disponível. Para obter mais informações sobre vinculação de versão em tempo de compilação, consulte Selecione a versão .NET a ser usada.

Vantagens

• Controlar a versão do .NET: controle qual versão do .NET é implantada com o aplicativo.
• Segmentação específica da plataforma: como o aplicativo deve ser publicado para cada plataforma, fica claro onde o aplicativo é executado.

Desvantagens

• Implantações maiores: como o aplicativo inclui o tempo de execução do .NET e todas as dependências, o tamanho do download e o espaço no disco rígido necessários são maiores do que uma implantação dependente da estrutura.
• Mais difícil de atualizar a versão do .NET: O .NET Runtime só pode ser atualizado lançando uma nova versão do aplicativo.

Dica

Você pode reduzir o tamanho total de aplicativos autônomos compatíveis publicando cortados ou habilitando o modo invariante de globalização. Para obter mais informações sobre o modo invariante de globalização, consulte Modo invariante de globalização do .NET.

Publicar

dotnet publish -c Release -r <RID> --self-contained true

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

• --self-contained true

  Essa opção informa ao SDK do .NET para criar um executável como uma implantação autônoma (SCD).

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Modo de Implantação como Autônomo.
6. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).
7. Selecione Salvar e, em seguida, Publicar.

Implantação de arquivo único

Quando você publica seu aplicativo como uma implantação de arquivo único, todos os arquivos dependentes do aplicativo são agrupados em um único binário. Esse modelo de implantação está disponível para aplicativos dependentes da estrutura e autônomos, fornecendo uma opção atraente para implantar e distribuir seu aplicativo como um único arquivo.

Os aplicativos de arquivo único são sempre específicos do sistema operacional e da arquitetura. Você precisa publicar para cada configuração, como Linux x64, Linux Arm64, Windows x64 e assim por diante.

Vantagens

• Distribuição simplificada: implante e distribua seu aplicativo como um único arquivo executável.
• Redução da desorganização de arquivos: todas as dependências são agrupadas, eliminando a necessidade de gerenciar vários arquivos.
• Fácil implantação: copie um único arquivo para implantar o aplicativo.

Desvantagens

• Tamanho de arquivo maior: o arquivo único inclui todas as dependências, tornando-o maior do que arquivos individuais.
• Arranque mais lento: Os ficheiros têm de ser extraídos em tempo de execução, o que pode afetar o desempenho do arranque.
• Específico da plataforma: Deve publicar arquivos separados para cada plataforma de destino.

A implantação de um único arquivo pode ser combinada com outras otimizações, como corte e compilação ReadyToRun para otimização adicional.

Para obter mais informações sobre a implantação de arquivo único, consulte Implantação de arquivo único.

Publicar

dotnet publish -c Release -r <RID> -p:PublishSingleFile=true

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

• -p:PublishSingleFile=true

  Essa propriedade agrupa todos os arquivos dependentes do aplicativo em um único binário.

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Modo de Implantação como Autônomo ou dependente da Estrutura.
6. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).
7. Marque Produzir arquivo único.
8. Selecione Salvar e, em seguida, Publicar.

Implantação de AOT nativa

A implantação nativa da AOT compila seu aplicativo diretamente no código nativo, eliminando a necessidade de um tempo de execução. Essa opção de publicação usa o modo de implantação independente , pois o código nativo compilado deve incluir tudo o que é necessário para executar o aplicativo. Isso resulta em tempos de inicialização mais rápidos e uso de memória reduzido, mas vem com algumas limitações nos recursos suportados.

Vantagens

• Arranque rápido: Não é necessária compilação JIT em tempo de execução, o que leva a um arranque da aplicação mais rápido.
• Uso de memória reduzido: menor espaço ocupado por memória em comparação com aplicativos .NET tradicionais.
• Sem dependência de tempo de execução: O aplicativo é executado sem exigir a instalação do .NET runtime.
• Tamanho de implantação menor: geralmente menor do que a implantação autônoma com o tempo de execução completo.

Desvantagens

• Suporte limitado à estrutura: nem todos os recursos e bibliotecas do .NET são compatíveis com a AOT nativa.
• Tempos de compilação mais longos: a compilação para código nativo leva mais tempo do que as compilações normais.
• Específico da plataforma: Deve compilar separadamente para cada plataforma e arquitetura de destino.
• Limitações de depuração: Experiência de depuração mais complexa em comparação com aplicativos .NET regulares.

Para obter mais informações sobre a implantação de AOT nativa, consulte Implantação de AOT nativa.

Publicar

dotnet publish -c Release -r <RID> -p:PublishAot=true

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

• -p:PublishAot=true

  Essa propriedade permite a compilação AOT nativa, que compila o aplicativo diretamente no código nativo.

A publicação AOT nativa deve ser configurada no arquivo de projeto. Você não pode habilitá-lo por meio da interface do usuário de publicação do Visual Studio.

1. No Gerenciador de Soluções, clique com o botão direito do mouse em seu projeto e selecione Editar arquivo de projeto.

2. Adicione a seguinte propriedade a um <PropertyGroup>arquivo :

   <PublishAot>true</PublishAot>
   

3. Salve o arquivo de projeto.

4. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.

5. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.

6. Escolha um local de pasta ou aceite o padrão e selecione Concluir.

7. No perfil de publicação, selecione Mostrar todas as configurações.

8. Defina o Modo de Implantação como Autônomo.

9. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).

10. Selecione Salvar e, em seguida, Publicar.

Para obter mais informações sobre a implantação de AOT nativa, consulte Implantação de AOT nativa.

Implantação do ReadyToRun

Quando você publica seu aplicativo com a compilação ReadyToRun, seus assemblies de aplicativo são compilados como formato ReadyToRun (R2R). O R2R é uma forma de compilação ahead-of-time (AOT) que melhora o desempenho de inicialização reduzindo a quantidade de trabalho que o compilador just-in-time (JIT) precisa fazer enquanto seu aplicativo é carregado. Essa opção de publicação pode ser usada com os modos de implantaçãoindependente e dependente da estrutura.

Os binários ReadyToRun contêm código de linguagem intermediária (IL) e a versão nativa do mesmo código. Embora os binários R2R sejam maiores do que os assemblies regulares, eles fornecem um melhor desempenho de inicialização.

Vantagens

• Tempo de inicialização aprimorado: o aplicativo gasta menos tempo executando o compilador JIT durante a inicialização.
• Melhor desempenho de primeira utilização: latência reduzida para a primeira execução de caminhos de código.
• Compatível com código existente: Funciona com a maioria das bibliotecas e estruturas .NET sem modificação.
• Implantação flexível: pode ser combinada com a implantação dependente da estrutura e com os modos de implantação independente .

Desvantagens

• Tamanho maior: o aplicativo é maior no disco devido à inclusão de IL e código nativo.
• Tempos de compilação mais longos: a compilação leva mais tempo do que a publicação padrão.
• Otimizações específicas da plataforma: os melhores ganhos de desempenho exigem a segmentação de plataformas específicas.

Publicar

dotnet publish -c Release -r <RID> -p:PublishReadyToRun=true

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

• -p:PublishReadyToRun=true

  Essa propriedade permite a compilação ReadyToRun, que melhora o desempenho de inicialização pré-compilando assemblies.

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Se esta for a primeira vez que publica, selecione Pasta como destino de publicação e selecione Avançar.
3. Escolha um local de pasta ou aceite o padrão e selecione Concluir.
4. No perfil de publicação, selecione Mostrar todas as configurações.
5. Defina o Modo de Implantação como Autônomo ou dependente da Estrutura.
6. Defina o Target Runtime para a plataforma desejada (por exemplo, win-x64 para Windows de 64 bits).
7. Marque Ativar compilação ReadyToRun.
8. Selecione Salvar e, em seguida, Publicar.

Para obter mais informações sobre a implantação do ReadyToRun, consulte Compilação do ReadyToRun.

Implantação de contêiner

Quando você publica seu aplicativo como um contêiner, o SDK do .NET empacota seu aplicativo e suas dependências em uma imagem de contêiner sem exigir um Dockerfile separado. Esse modo de implantação cria uma imagem de contêiner completa que pode ser executada em qualquer tempo de execução de contêiner, como Docker ou Podman. A implantação de contêineres simplifica o processo de conteinerização, eliminando a necessidade de escrever e manter Dockerfiles enquanto fornece imagens de base otimizadas.

A partir do .NET SDK 8.0.200, o suporte a contêineres está incluído por padrão e não requer pacotes NuGet extras. Para aplicativos de console, talvez seja necessário habilitar o suporte a contêineres explicitamente definindo a EnableSdkContainerSupport propriedade como true.

Dica

Para obter mais informações sobre configurações de projeto relacionadas a contêineres, consulte Containerize a .NET app reference.

Vantagens

• Contentorização simplificada: Não há necessidade de escrever ou manter Dockerfiles para cenários básicos.
• Imagens base otimizadas: usa imagens base otimizadas fornecidas pela Microsoft com as atualizações de segurança mais recentes.
• Ambiente consistente: garante um ambiente de tempo de execução consistente em todo o desenvolvimento, teste e produção.
• Fácil distribuição: as imagens de contêiner podem ser facilmente compartilhadas e implantadas em diferentes ambientes.
• Isolamento da plataforma: os aplicativos são executados em contêineres isolados, reduzindo conflitos entre aplicativos.

Desvantagens

• Dependência de tempo de execução de contêiner: O ambiente de destino deve ter um tempo de execução de contêiner instalado.
• Tamanho da imagem: as imagens de contêiner geralmente são maiores do que outros métodos de implantação.
• Curva de aprendizagem: Requer compreensão de conceitos de contêiner e ferramentas.
• Personalização limitada: Menos flexibilidade em comparação com Dockerfiles personalizados para cenários complexos.

Publicar

dotnet publish -c Release [-r <RID>] /t:PublishContainer

• -c Release

  Esse switch define a configuração de compilação como Release, que é otimizada para implantação em produção.

• -r <RID>

  Essa opção usa um identificador de tempo de execução (RID) para especificar a plataforma de destino e garante que as dependências nativas sejam incluídas (se necessário). Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

• -t:PublishContainer

  Esse destino publica o aplicativo como uma imagem de contêiner.

Você também pode usar a abordagem de perfil de publicação:

dotnet publish -c Release [-r <RID>] -p:PublishProfile=DefaultContainer

• -p:PublishProfile=DefaultContainer

  Esse perfil aciona o processo de publicação de contêiner.

1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Publicar.
2. Selecione Registro de contêiner como o destino de publicação e selecione Avançar.
3. Escolha seu registro de contêiner de destino (como Registro de Contêiner do Azure, Hub do Docker ou Registro Genérico) e selecione Avançar.
4. Configure os detalhes da conexão do Registro e a autenticação.
5. No perfil de publicação, selecione Mostrar todas as configurações.
6. Defina o Modo de Implantação como Autônomo ou Dependente da Estrutura com base em suas necessidades.
7. Defina o Target Runtime para a plataforma desejada (por exemplo, linux-x64 para contêineres Linux).
8. Configure configurações específicas do contêiner, como nome da imagem e tags.
9. Selecione Salvar e, em seguida, Publicar.

Para obter mais informações sobre a implantação de contêiner, consulte Visão geral da criação de contêiner do SDK do .NET.

Ver também

• Catálogo do .NET Runtime Identifier (RID)
• Selecione a versão .NET a ser usada
• Publicação para macOS