Pacote de distribuição do .NET Core.NET Core distribution packaging

À medida que o .NET Core fica disponível em mais plataformas, é muito útil saber como empacotar, nomear e controlar a versão dele.As .NET Core becomes available on more and more platforms, it's useful to learn how to package, name, and version it. Dessa forma, os mantenedores do pacote podem ajudar a garantir uma experiência consistente, independentemente de onde os usuários escolhem executar o .NET.This way, package maintainers can help ensure a consistent experience no matter where users choose to run .NET. Este artigo é útil para usuários que estão:This article is useful for users that are:

  • Tentando criar o .NET Core com base na origem.Attempting to build .NET Core from source.
  • Querendo fazer alterações à CLI do .NET Core que poderiam afetar o layout resultante ou os pacotes produzidos.Wanting to make changes to the .NET Core CLI that could impact the resulting layout or packages produced.

Layout de discoDisk layout

Quando instalado, o .NET Core consiste em vários componentes que são dispostos da seguinte maneira no sistema de arquivos:When installed, .NET Core consists of several components that are laid out as follows in the filesystem:

{dotnet_root}                                     (*)
├── dotnet                       (1)
├── LICENSE.txt                  (8)
├── ThirdPartyNotices.txt        (8)
├── host                                          (*)
│   └── fxr                                       (*)
│       └── <fxr version>        (2)
├── sdk                                           (*)
│   ├── <sdk version>            (3)
│   └── NuGetFallbackFolder      (4)              (*)
├── packs                                         (*)
│   ├── Microsoft.AspNetCore.App.Ref              (*)
│   │   └── <aspnetcore ref version>     (11)
│   ├── Microsoft.NETCore.App.Ref                 (*)
│   │   └── <netcore ref version>        (12)
│   ├── Microsoft.NETCore.App.Host.<rid>          (*)
│   │   └── <apphost version>            (13)
│   ├── Microsoft.WindowsDesktop.App.Ref          (*)
│   │   └── <desktop ref version>        (14)
│   └── NETStandard.Library.Ref                   (*)
│       └── <netstandard version>        (15)
├── shared                                        (*)
│   ├── Microsoft.NETCore.App                     (*)
│   │   └── <runtime version>     (5)
│   ├── Microsoft.AspNetCore.App                  (*)
│   │   └── <aspnetcore version>  (6)
│   ├── Microsoft.AspNetCore.All                  (*)
│   │   └── <aspnetcore version>  (6)
│   └── Microsoft.WindowsDesktop.App              (*)
│       └── <desktop app version> (7)
└── templates                                     (*)
│   └── <templates version>      (17)
/
├── etc/dotnet
│       └── install_location     (16)
├── usr/share/man/man1
│       └── dotnet.1.gz          (9)
└── usr/bin
        └── dotnet               (10)
  • (1) dotnet O host (também conhecido como o "muxer") tem duas funções distintas: ativar um tempo de execução para iniciar um aplicativo e ativar um SDK para enviar comandos a ele.(1) dotnet The host (also known as the "muxer") has two distinct roles: activate a runtime to launch an application, and activate an SDK to dispatch commands to it. O host é um executável nativo (dotnet.exe).The host is a native executable (dotnet.exe).

Embora haja um único host, a maioria dos outros componentes está em diretórios com controle de versão (2,3,5,6).While there's a single host, most of the other components are in versioned directories (2,3,5,6). Isso significa que várias versões podem estar presentes no sistema, pois são instaladas lado a lado.This means multiple versions can be present on the system since they're installed side by side.

  • (2) host/fxr/<versão do fxr> contém a lógica de resolução do framework usada pelo host.(2) host/fxr/<fxr version> contains the framework resolution logic used by the host. O host usa o hostfxr mais recente instalado.The host uses the latest hostfxr that is installed. O hostfxr é responsável por selecionar o runtime apropriado ao executar um aplicativo .NET Core.The hostfxr is responsible for selecting the appropriate runtime when executing a .NET Core application. Por exemplo, um aplicativo criado para o runtime do .NET Core 2.0.0 usa o 2.0.5 quando ele está disponível.For example, an application built for .NET Core 2.0.0 uses the 2.0.5 runtime when it's available. Da mesma forma, o hostfxr seleciona o SDK adequado durante o desenvolvimento.Similarly, hostfxr selects the appropriate SDK during development.

  • (3) sdk/<versão do sdk> O SDK (também conhecido como "as ferramentas") é um conjunto de ferramentas gerenciadas usado para escrever e compilar aplicativos e bibliotecas do .NET Core.(3) sdk/<sdk version> The SDK (also known as "the tooling") is a set of managed tools that are used to write and build .NET Core libraries and applications. O SDK inclui a CLI (interface de linha de comando) do .NET Core, os compiladores de linguagens gerenciadas, o MSBuild, tarefas e destinos de compilação associados, o NuGet, novos modelos de projeto e assim por diante.The SDK includes the .NET Core Command-line interface (CLI), the managed languages compilers, MSBuild, and associated build tasks and targets, NuGet, new project templates, and so on.

  • (4) sdk/NuGetFallbackFolder contém um cache de pacotes do NuGet usados por um SDK durante a operação de restauração, como ao executar dotnet restore ou dotnet build.(4) sdk/NuGetFallbackFolder contains a cache of NuGet packages used by an SDK during the restore operation, such as when running dotnet restore or dotnet build. Esta pasta é usada somente antes do .NET Core 3,0.This folder is only used prior to .NET Core 3.0. Ele não pode ser compilado da origem, pois contém ativos binários pré-criados de nuget.org.It can't be built from source, because it contains prebuilt binary assets from nuget.org.

A pasta compartilhada contém estruturas.The shared folder contains frameworks. Uma estrutura compartilhada fornece um conjunto de bibliotecas em um local central para que elas possam ser usadas por aplicativos diferentes.A shared framework provides a set of libraries at a central location so they can be used by different applications.

  • (5) shared/Microsoft.NETCore.App/<versão do tempo de execução> Essa estrutura contém o tempo de execução do .NET Core e as bibliotecas gerenciadas que dão suporte a ele.(5) shared/Microsoft.NETCore.App/<runtime version> This framework contains the .NET Core runtime and supporting managed libraries.

  • (6) Shared/Microsoft. AspNetCore. { App, All}/<aspnetcore versão > contém as bibliotecas de ASP.NET Core.(6) shared/Microsoft.AspNetCore.{App,All}/<aspnetcore version> contains the ASP.NET Core libraries. As bibliotecas em Microsoft.AspNetCore.App são desenvolvidas e têm suporte como parte do projeto .NET Core.The libraries under Microsoft.AspNetCore.App are developed and supported as part of the .NET Core project. As bibliotecas em Microsoft.AspNetCore.All são um superconjunto que também contém bibliotecas de terceiros.The libraries under Microsoft.AspNetCore.All are a superset that also contains third-party libraries.

  • (7) Shared/Microsoft. desktop. app/@no__t-a versão do aplicativo 1desktop > contém as bibliotecas da área de trabalho do Windows.(7) shared/Microsoft.Desktop.App/<desktop app version> contains the Windows desktop libraries. Isso não está incluído em plataformas não Windows.This isn't included on non-Windows platforms.

  • (8) LICENSE.txt,ThirdPartyNotices.txt são a licença do .NET Core e licenças de bibliotecas de terceiros usadas no .NET Core, respectivamente.(8) LICENSE.txt,ThirdPartyNotices.txt are the .NET Core license and licenses of third-party libraries used in .NET Core, respectively.

  • (9,10) dotnet.1.gz, dotnet dotnet.1.gz é a página de manual do dotnet.(9,10) dotnet.1.gz, dotnet dotnet.1.gz is the dotnet manual page. dotnet é um symlink ao host(1) dotnet.dotnet is a symlink to the dotnet host(1). Esses arquivos são instalados em locais bem conhecidos para a integração do sistema.These files are installed at well known locations for system integration.

  • (11, 12) Microsoft. NetCore. app. ref, Microsoft. AspNetCore. app. ref descreve a API de uma versão x.y do .NET Core e ASP.NET Core, respectivamente.(11,12) Microsoft.NETCore.App.Ref,Microsoft.AspNetCore.App.Ref describe the API of an x.y version of .NET Core and ASP.NET Core respectively. Esses pacotes são usados durante a compilação para essas versões de destino.These packs are used when compiling for those target versions.

  • (13) Microsoft. NetCore. app. host. <rid > contém um binário nativo para a plataforma rid.(13) Microsoft.NETCore.App.Host.<rid> contains a native binary for platform rid. Esse binário é um modelo ao compilar um aplicativo .NET Core em um binário nativo para essa plataforma.This binary is a template when compiling a .NET Core application into a native binary for that platform.

  • (14) Microsoft. WindowsDesktop. app. ref descreve a API da versão x.y dos aplicativos da área de trabalho do Windows.(14) Microsoft.WindowsDesktop.App.Ref describes the API of x.y version of Windows Desktop applications. Esses arquivos são usados durante a compilação para esse destino.These files are used when compiling for that target. Isso não é fornecido em plataformas não Windows.This isn't provided on non-Windows platforms.

  • (15) netstandard. library. ref descreve a API do netpadrão x.y.(15) NETStandard.Library.Ref describes the netstandard x.y API. Esses arquivos são usados durante a compilação para esse destino.These files are used when compiling for that target.

  • (16) /etc/dotnet/install_location é um arquivo que contém o caminho completo para {dotnet_root}.(16) /etc/dotnet/install_location is a file that contains the full path for {dotnet_root}. O caminho pode terminar com uma nova linha.The path may end with a newline. Não é necessário adicionar esse arquivo quando a raiz é /usr/share/dotnet.It's not necessary to add this file when the root is /usr/share/dotnet.

  • (17) modelos contém os modelos usados pelo SDK.(17) templates contains the templates used by the SDK. Por exemplo, dotnet new localiza modelos de projeto aqui.For example, dotnet new finds project templates here.

As pastas marcadas com (*) são usadas por vários pacotes.The folders marked with (*) are used by multiple packages. Alguns formatos de pacote (por exemplo, rpm) exigem um tratamento especial dessas pastas.Some package formats (for example, rpm) require special handling of such folders. O mantenedor do pacote deve cuidar disso.The package maintainer must take care of this.

O controle de versão do .NET Core é baseado nos números de versão [major].[minor] do componente de tempo de execução..NET Core versioning is based on the runtime component [major].[minor] version numbers. A versão do SDK usa o mesmo [major].[minor] e tem um [patch] independente que combina as semânticas de recurso e de patch para o SDK.The SDK version uses the same [major].[minor] and has an independent [patch] that combines feature and patch semantics for the SDK. Por exemplo: SDK versão 2.2.302 é a segunda versão de patch da terceira versão de recurso do SDK que dá suporte ao tempo de execução 2,2.For example: SDK version 2.2.302 is the second patch release of the third feature release of the SDK that supports the 2.2 runtime. Para obter mais informações sobre como o controle de versão funciona, veja Visão geral do controle de versão do .NET Core.For more information about how versioning works, see .NET Core versioning overview.

Alguns pacotes incluem parte do número de versão no nome deles.Some of the packages include part of the version number in their name. Isso permite que você instale uma versão específica.This allows you to install a specific version. O restante da versão não está incluído no nome da versão.The rest of the version isn't included in the version name. Isso permite ao gerenciador de pacotes de SO atualize os pacotes (por exemplo, instalando automaticamente correções de segurança).This allows the OS package manager to update the packages (for example, automatically installing security fixes). Gerenciadores de pacotes com suporte são específicos do Linux.Supported package managers are Linux specific.

Veja a seguir uma lista dos pacotes recomendados:The following lists the recommended packages:

  • dotnet-sdk-[major].[minor]-instala o SDK mais recente para tempo de execução específicodotnet-sdk-[major].[minor] - Installs the latest sdk for specific runtime

    • Versão: versão <runtime >Version: <runtime version>
    • Exemplo: dotnet-sdk-2,1Example: dotnet-sdk-2.1
    • Contém: (3), (4)Contains: (3),(4)
    • Dependências: dotnet-runtime-[major].[minor], aspnetcore-runtime-[major].[minor], dotnet-targeting-pack-[major].[minor], aspnetcore-targeting-pack-[major].[minor], netstandard-targeting-pack-[netstandard_major].[netstandard_minor], dotnet-apphost-pack-[major].[minor], dotnet-templates-[major].[minor]Dependencies: dotnet-runtime-[major].[minor], aspnetcore-runtime-[major].[minor], dotnet-targeting-pack-[major].[minor], aspnetcore-targeting-pack-[major].[minor], netstandard-targeting-pack-[netstandard_major].[netstandard_minor], dotnet-apphost-pack-[major].[minor], dotnet-templates-[major].[minor]
  • aspnetcore-runtime-[major].[minor]-instala um tempo de execução de ASP.NET Core específicoaspnetcore-runtime-[major].[minor] - Installs a specific ASP.NET Core runtime

    • Versão: versão de tempo de execução <aspnetcore >Version: <aspnetcore runtime version>
    • Exemplo: aspnetcore-runtime-2,1Example: aspnetcore-runtime-2.1
    • Contém: (6)Contains: (6)
    • Dependências: dotnet-runtime-[major].[minor]Dependencies: dotnet-runtime-[major].[minor]
  • dotnet-runtime-deps-[major].[minor] (opcional) – instala as dependências para executar aplicativos independentesdotnet-runtime-deps-[major].[minor] (Optional) - Installs the dependencies for running self-contained applications

    • Versão: versão <runtime >Version: <runtime version>
    • Exemplo: dotnet-Runtime-deps-2,1Example: dotnet-runtime-deps-2.1
    • Dependências: dependências específicas do distribuiçãoDependencies: distro specific dependencies
  • dotnet-runtime-[major].[minor]-instala um tempo de execução específicodotnet-runtime-[major].[minor] - Installs a specific runtime

    • Versão: versão <runtime >Version: <runtime version>
    • Exemplo: dotnet-tempo de execução-2,1Example: dotnet-runtime-2.1
    • Contém: (5)Contains: (5)
    • Dependências: dotnet-hostfxr-[major].[minor], dotnet-runtime-deps-[major].[minor]Dependencies: dotnet-hostfxr-[major].[minor], dotnet-runtime-deps-[major].[minor]
  • dotnet-hostfxr-[major].[minor]-dependênciadotnet-hostfxr-[major].[minor] - dependency

    • Versão: versão <runtime >Version: <runtime version>
    • Exemplo: dotnet-hostfxr-3,0Example: dotnet-hostfxr-3.0
    • Contém: (2)Contains: (2)
    • Dependências: dotnet-hostDependencies: dotnet-host
  • dotnet-host-dependênciadotnet-host - dependency

    • Versão: versão <runtime >Version: <runtime version>
    • Exemplo: dotnet-hostExample: dotnet-host
    • Contém: (1), (8), (9), (10), (16)Contains: (1),(8),(9),(10),(16)
  • dotnet-apphost-pack-[major].[minor]-dependênciadotnet-apphost-pack-[major].[minor] - dependency

    • Versão: versão <runtime >Version: <runtime version>
    • Contém: (13)Contains: (13)
  • dotnet-targeting-pack-[major].[minor]-permite direcionar um tempo de execução não mais recentedotnet-targeting-pack-[major].[minor] - Allows targeting a non-latest runtime

    • Versão: versão <runtime >Version: <runtime version>
    • Contém: (12)Contains: (12)
  • aspnetcore-targeting-pack-[major].[minor]-permite direcionar um tempo de execução não mais recenteaspnetcore-targeting-pack-[major].[minor] - Allows targeting a non-latest runtime

    • Versão: versão de tempo de execução <aspnetcore >Version: <aspnetcore runtime version>
    • Contém: (11)Contains: (11)
  • netstandard-targeting-pack-[netstandard_major].[netstandard_minor]-permite direcionar uma versão do netstandardnetstandard-targeting-pack-[netstandard_major].[netstandard_minor] - Allows targeting a netstandard version

    • Versão: versão <sdk >Version: <sdk version>
    • Contém: (15)Contains: (15)
  • dotnet-templates-[major].[minor]

    • Versão: versão <sdk >Version: <sdk version>
    • Contém: (15)Contains: (15)

O dotnet-runtime-deps-[major].[minor] requer a compreensão das dependências específicas do distribuição.The dotnet-runtime-deps-[major].[minor] requires understanding the distro-specific dependencies. Como o sistema de compilação distribuição pode ser capaz de derivar isso automaticamente, o pacote é opcional; nesse caso, essas dependências são adicionadas diretamente ao pacote dotnet-runtime-[major].[minor].Because the distro build system may be able to derive this automatically, the package is optional, in which case these dependencies are added directly to the dotnet-runtime-[major].[minor] package.

Quando o conteúdo do pacote está sob uma pasta com versão, o nome do pacote [major].[minor] corresponde ao nome da pasta com versão.When package content is under a versioned folder, the package name [major].[minor] match the versioned folder name. Para todos os pacotes, exceto o netstandard-targeting-pack-[netstandard_major].[netstandard_minor], isso também corresponde à versão do .NET Core.For all packages, except the netstandard-targeting-pack-[netstandard_major].[netstandard_minor], this also matches with the .NET Core version.

As dependências entre os pacotes devem usar um requisito de versão igual ou maior que .Dependencies between packages should use an equal or greater than version requirement. Por exemplo, dotnet-sdk-2.2:2.2.401 requer aspnetcore-runtime-2.2 >= 2.2.6.For example, dotnet-sdk-2.2:2.2.401 requires aspnetcore-runtime-2.2 >= 2.2.6. Isso possibilita que o usuário Atualize sua instalação por meio de um pacote raiz (por exemplo, dnf update dotnet-sdk-2.2).This makes it possible for the user to upgrade their installation via a root package (for example, dnf update dotnet-sdk-2.2).

A maioria das distribuições exigem que todos os artefatos sejam compilados da origem.Most distributions require all artifacts to be built from source. Isso tem algum impacto nos pacotes:This has some impact on the packages:

  • As bibliotecas de terceiros em shared/Microsoft.AspNetCore.All não podem ser criadas facilmente usando o código-fonte.The third-party libraries under shared/Microsoft.AspNetCore.All can't be easily built from source. Portanto, essa pasta é omitida do pacote aspnetcore-runtime.So that folder is omitted from the aspnetcore-runtime package.

  • O NuGetFallbackFolder é populado usando os artefatos binários de nuget.org.The NuGetFallbackFolder is populated using binary artifacts from nuget.org. Ele deve permanecer vazio.It should remain empty.

Vários pacotes dotnet-sdk podem fornecer os mesmos arquivos para o NuGetFallbackFolder.Multiple dotnet-sdk packages may provide the same files for the NuGetFallbackFolder. Para evitar problemas com o gerenciador de pacotes, esses arquivos devem ser idênticos (soma de verificação, data de modificação e assim por diante).To avoid issues with the package manager, these files should be identical (checksum, modification date, and so on).

Compilando pacotesBuilding packages

O repositório dotnet/source-build fornece instruções sobre como compilar um tarball de origem do SDK do .NET Core e todos os seus componentes.The dotnet/source-build repository provides instructions on how to build a source tarball of the .NET Core SDK and all its components. A saída do repositório de build de origem corresponde o layout descrito na primeira seção deste artigo.The output of the source-build repository matches the layout described in the first section of this article.