Partilhar via

Contentorizar uma referência de aplicação .NET

Neste artigo de referência, você aprenderá a configurar a imagem de contêiner gerada quando você publica um aplicativo .NET como um contêiner. Este artigo aborda as várias propriedades que você pode definir para controlar a imagem, o ambiente de execução e os comandos que são executados quando o contêiner é iniciado.

Configurar propriedades de contêiner

Você pode controlar muitos aspetos do contêiner gerado por meio das propriedades do MSBuild. Em geral, se você pode usar um comando em um Dockerfile para definir alguma configuração, você pode fazer o mesmo via MSBuild.

Observação

As únicas exceções são RUN comandos. Devido à forma como os contêineres são construídos, esses comandos não podem ser emulados. Se você precisar dessa funcionalidade, considere usar um Dockerfile para criar suas imagens de contêiner.

Não é possível executar comandos RUN com o SDK do .NET. Esses comandos são frequentemente usados para instalar alguns pacotes do sistema operacional ou criar um novo usuário do sistema operacional, ou qualquer número de coisas arbitrárias. Se você quiser continuar usando o recurso de criação de contêiner do SDK do .NET, poderá criar uma imagem base personalizada com essas alterações e, em seguida, usar essa imagem base. Para obter mais informações, consulte ContainerBaseImage.

Sinalizadores que controlam a imagem base

As propriedades a seguir controlam qual imagem base é usada para seu contêiner e como ela é selecionada:

ContainerBaseImage

A propriedade container base image controla a imagem usada como base para sua imagem. Por padrão, os seguintes valores são inferidos com base nas propriedades do seu projeto:

  • Se o seu projeto for independente, a imagem mcr.microsoft.com/dotnet/runtime-deps será usada como imagem base.
  • Se o seu projeto for um projeto ASP.NET Core, a imagem mcr.microsoft.com/dotnet/aspnet será usada como imagem base.
  • Caso contrário, a imagem mcr.microsoft.com/dotnet/runtime é usada como imagem base.

A tag da imagem é inferida como sendo o componente numérico do TargetFrameworkescolhido. Por exemplo, um projeto direcionado a net6.0 resulta na tag 6.0 da imagem base inferida e um projeto net7.0-linux usa a tag 7.0 e assim por diante.

Se você definir um valor aqui, deverá definir o nome totalmente qualificado da imagem para usar como base, incluindo qualquer tag de sua preferência:

<PropertyGroup>
    <ContainerBaseImage>mcr.microsoft.com/dotnet/runtime:8.0</ContainerBaseImage>
</PropertyGroup>

Com o .NET SDK versão 8.0.200, a inferência de ContainerBaseImage é melhorada para otimizar o tamanho e a segurança:

  • Direcionando os identificadores de tempo de execução linux-musl-x64 ou linux-musl-arm64, escolhe automaticamente as variantes de imagem alpine para garantir que seu projeto seja executado:
    • Se o projeto usa PublishAot=true então a nightly/runtime-depsjammy-chiseled-aot variante da imagem base para melhor tamanho e segurança.
    • Se o projeto usar InvariantGlobalization=false, as variantes de -extra serão usadas para garantir que a localização ainda funcione.

Para obter mais informações sobre os tamanhos e características das variantes de imagem, consulte .NET 8.0 Container Image Size Report.

ContainerFamily

A partir do .NET 8, você pode usar a propriedade ContainerFamily MSBuild para escolher uma família diferente de imagens de contêiner fornecidas pela Microsoft como a imagem base para seu aplicativo. Quando definido, esse valor é anexado ao final da tag específica do TFM selecionada, alterando a tag fornecida. Por exemplo, para usar as variantes do Alpine Linux das imagens base do .NET, você pode definir ContainerFamily para alpine:

<PropertyGroup>
    <ContainerFamily>alpine</ContainerFamily>
</PropertyGroup>

A configuração do projeto anterior resulta em uma marca final de 8.0-alpine para um aplicativo de destino .NET 8.

Este campo é de forma livre e, muitas vezes, pode ser usado para selecionar diferentes distribuições do sistema operacional, configurações de pacote padrão ou qualquer outro de sabor de alterações em uma imagem base. Este campo é ignorado quando ContainerBaseImage é definido. Para obter mais informações, consulte imagens de contentores .NET .

ContainerRuntimeIdentifier(s)

A propriedade ContainerRuntimeIdentifier especifica o sistema operacional e a arquitetura do contêiner se o ContainerBaseImage oferecer suporte a várias plataformas. Por exemplo, a imagem mcr.microsoft.com/dotnet/runtime suporta linux-x64, linux-arm, linux-arm64e win10-x64. Por padrão, isso é definido como o RuntimeIdentifier usado ao publicar o contêiner. Normalmente, você não precisa definir essa propriedade explicitamente; Em vez disso, use a opção -r com o comando dotnet publish. Se a imagem escolhida não suportar o RuntimeIdentifierespecificado, um erro indica os identificadores suportados.

Você sempre pode definir a propriedade ContainerBaseImage como um nome de imagem totalmente qualificado, incluindo a tag , para evitar a necessidade de usar essa propriedade.

<PropertyGroup>
    <ContainerRuntimeIdentifier>linux-arm64</ContainerRuntimeIdentifier>
</PropertyGroup>

Para especificar vários identificadores de tempo de execução de contêiner para imagens de várias arquiteturas, use um conjunto delimitado por ponto-e-vírgula de identificadores de tempo de execução na propriedade ContainerRuntimeIdentifiers, semelhante à configuração de vários TargetFrameworks:

<PropertyGroup>
    <ContainerRuntimeIdentifiers>linux-x64;linux-arm64</ContainerRuntimeIdentifiers>
</PropertyGroup>

Importante

A ContainerRuntimeIdentifiers propriedade deve ser um subconjunto da RuntimeIdentifiers propriedade. Se essa condição não for atendida, partes críticas do pipeline de compilação poderão falhar.

A definição de vários ContainerRuntimeIdentifiers resultados em uma imagem de várias arquiteturas está sendo criada. Para obter mais informações, consulte Imagens com várias arquiteturas.

Para obter mais informações sobre os identificadores de tempo de execução suportados pelo .NET, consulte Catálogo RID.

Imagens multi-arquitectura

As imagens multiarquitetura permitem que uma única imagem de contêiner ofereça suporte a várias arquiteturas, simplificando o desenvolvimento e a implantação entre plataformas. O SDK do .NET oferece suporte a isso por meio da ContainerRuntimeIdentifiers propriedade.

A partir das versões 8.0.405, 9.0.102 e 9.0.2xx do SDK, há suporte para a publicação de contêineres multi-RID. Ao publicar com /t:PublishContainer:

  • Se um único RuntimeIdentifier ou ContainerRuntimeIdentifier for especificado, um contêiner de arquitetura única será gerado como antes.
  • Se nenhum único RuntimeIdentifier for especificado, mas múltiplo RuntimeIdentifiers ou ContainerRuntimeIdentifiers estiver definido, o SDK publicará o aplicativo para cada RID especificado e combinará as imagens resultantes em um OCI Image Index. Esse índice permite que várias imagens específicas da arquitetura compartilhem um único nome.

Observação

A ContainerRuntimeIdentifiers propriedade deve ser um subconjunto da RuntimeIdentifiers propriedade. Para obter mais informações, consulte ContainerRuntimeIdentifiers.

Esse recurso simplifica os fluxos de trabalho de contêiner em ambientes de arquitetura mista. Por exemplo, um desenvolvedor em um linux-x64 host pode publicar um contêiner que suporte ambos e linux-x64linux-arm64, permitindo a implantação em qualquer arquitetura sem alterar nomes de imagem ou rótulos.

O OCI Image Index gerado é amplamente suportado com ferramentas de contêiner modernas, melhorando a compatibilidade e a facilidade de uso.

Sinalizadores que controlam metadados independentes de imagem gerada

As propriedades a seguir controlam os metadados e a configuração que se aplicam à imagem de contêiner gerada, independentemente do identificador de tempo de execução de destino:

ContainerImageFormat

Você pode usar a ContainerImageFormat propriedade MSBuild para especificar o formato de imagem como ou DockerOCI . Por padrão, as ferramentas do .NET inferem o formato da imagem base. Por exemplo, as imagens de base do .NET usam o formato application/vnd.docker.distribution.manifest.v2+jsonespecífico do Docker. No entanto, muitas ferramentas modernas preferem o formato OCI application/vnd.oci.image.manifest.v1+json. Para forçar um formato específico, defina a propriedade como mostrado:

<PropertyGroup>
  <ContainerImageFormat>OCI</ContainerImageFormat>
</PropertyGroup>

Ambos os formatos são amplamente intercambiáveis sem perda de informação.

Observação

Ao criar uma imagem multiarquitetura, o formato de imagem resultante é sempre OCI.

ContainerImageTag

A propriedade container image tag controla as tags geradas para a imagem. Para especificar uma única tag use ContainerImageTag e para várias tags use ContainerImageTags.

Importante

Quando você usa ContainerImageTagso , acaba com várias imagens, uma por tag exclusiva.

As tags geralmente são usadas para se referir a diferentes versões de um aplicativo, mas também podem se referir a diferentes distribuições do sistema operacional ou até mesmo configurações diferentes.

A partir do .NET 8, quando uma tag não é fornecida, o padrão é latest.

Para substituir o padrão, especifique uma das seguintes propriedades:

<PropertyGroup>
    <ContainerImageTag>1.2.3-alpha2</ContainerImageTag>
</PropertyGroup>

Para especificar várias tags, use um conjunto de tags delimitado por ponto-e-vírgula na propriedade ContainerImageTags, semelhante à configuração de várias TargetFrameworks:

<PropertyGroup>
    <ContainerImageTags>1.2.3-alpha2;latest</ContainerImageTags>
</PropertyGroup>

As tags só podem conter até 127 caracteres alfanuméricos, pontos, sublinhados e traços. Devem começar com um caractere alfanumérico ou um sublinhado. Qualquer outro formulário resulta em um erro sendo lançado.

Observação

Ao usar ContainerImageTags ou qualquer propriedade MSBuild que exija ;valores -delimitados, garanta a fuga adequada ao chamar dotnet publish a partir da linha de comando, especialmente em ambientes CI/CD. As regras de escape diferem entre PowerShell e Bash. Por exemplo:

dotnet publish --os linux --arch x64 /t:PublishContainer /p:ContainerImageTags=`"1.2.3-alpha2`;latest`"

No PowerShell, os caracteres ; e " precisam ser escapados.

dotnet publish --os linux --arch x64 /t:PublishContainer /p:ContainerImageTags='"1.2.3-alpha2;latest"'

Em Bash, apenas o personagem " precisa ser escapado.

Isso resulta em duas imagens sendo geradas: my-app:1.2.3-alpha2 e my-app:latest.

Dica

Se você tiver problemas com a propriedade ContainerImageTags, considere definir o escopo de uma variável de ambiente ContainerImageTags em vez disso:

$Env:ContainerImageTags='1.2.3;latest'; dotnet publish --os linux --arch x64 /t:PublishContainer

ContainerLabel

O rótulo do contêiner adiciona um rótulo de metadados ao contêiner. Os rótulos são frequentemente usados para armazenar metadados de versão e criação para uso por scanners de segurança e outras ferramentas de infraestrutura. Você pode especificar qualquer número de rótulos de contêiner.

O nó ContainerLabel tem dois atributos:

  • Include: A chave do rótulo.
  • Value: O valor do rótulo (pode estar vazio).
<ItemGroup>
    <ContainerLabel Include="org.contoso.businessunit" Value="contoso-university" />
</ItemGroup>

Para obter uma lista de rótulos criados por padrão, consulte rótulos de contêiner padrão.

ContainerRepository

O repositório de contêiner é o nome da própria imagem, por exemplo, dotnet/runtime ou my-app. Por padrão, o AssemblyName do projeto é usado.

<PropertyGroup>
    <ContainerRepository>my-app</ContainerRepository>
</PropertyGroup>

Os nomes das imagens consistem em um ou mais segmentos delimitados por barras, cada um dos quais só pode conter caracteres alfanuméricos minúsculos, pontos, sublinhados e traços, e devem começar com uma letra ou número. Quaisquer outros caracteres resultam em um erro sendo lançado.

Sinalizadores que controlam metadados de execução

As propriedades a seguir controlam o comportamento de execução específico do tempo de execução e a geração de imagens de várias arquiteturas:

ContainerAppCommand

O item de configuração do comando do aplicativo é o ponto de entrada lógico do seu aplicativo. Para a maioria dos aplicativos, este é o AppHost, o binário executável gerado para seu aplicativo. Se o seu aplicativo não gerar um AppHost, esse comando normalmente é dotnet <your project dll>. Esses valores são aplicados após qualquer ENTRYPOINT em seu contêiner de base ou diretamente se nenhum ENTRYPOINT for definido.

A configuração ContainerAppCommand tem uma única propriedade Include, que representa o comando, opção ou argumento a ser usado no comando entrypoint:

<ItemGroup Label="ContainerAppCommand Assignment">
  <!-- This is how you would start the dotnet ef tool in your container -->
  <ContainerAppCommand Include="dotnet" />
  <ContainerAppCommand Include="ef" />

  <!-- This shorthand syntax means the same thing, note the semicolon separating the tokens. -->
  <ContainerAppCommand Include="dotnet;ef" />
</ItemGroup>

ContainerAppCommandArgs

Este item de configuração args do comando do aplicativo representa todos os argumentos logicamente necessários para seu aplicativo que devem ser aplicados ao ContainerAppCommand. Por padrão, nenhum é gerado para um aplicativo. Quando presentes, os args são aplicados ao seu contêiner quando ele é executado.

A configuração ContainerAppCommandArgs tem uma única propriedade Include, que representa a opção ou argumento a ser aplicado ao comando ContainerAppCommand.

<ItemGroup>
  <!-- Assuming the ContainerAppCommand defined above,
       this would be the way to force the database to update.
  -->
  <ContainerAppCommandArgs Include="database" />
  <ContainerAppCommandArgs Include="update" />

  <!-- This is the shorthand syntax for the same idea -->
  <ContainerAppCommandArgs Include="database;update" />
</ItemGroup>

ContainerAppCommandInstruction

A configuração de instruções de comando do aplicativo ajuda a controlar a maneira como os ContainerEntrypoint, ContainerEntrypointArgs, ContainerAppCommand, ContainerAppCommandArgse ContainerDefaultArgs são combinados para formar o comando final que é executado no contêiner. Isso depende muito se um ENTRYPOINT está presente na imagem base. Esta propriedade usa um dos três valores: "DefaultArgs", "Entrypoint"ou "None".

  • Entrypoint:
    • Neste modo, o ponto de entrada é definido por ContainerAppCommand, ContainerAppCommandArgse ContainerDefaultArgs.
  • None:
    • Neste modo, o ponto de entrada é definido por ContainerEntrypoint, ContainerEntrypointArgse ContainerDefaultArgs.
  • DefaultArgs:
    • Este é o modo mais complexo — se nenhum dos itens ContainerEntrypoint[Args] estiver presente, o ContainerAppCommand[Args] e o ContainerDefaultArgs serão usados para criar o ponto de entrada e o comando. O ponto de entrada da imagem base para imagens base que a codificam para dotnet ou /usr/bin/dotnet é ignorado para que você tenha controle total.
    • Se ContainerEntrypoint e ContainerAppCommand estiverem presentes, ContainerEntrypoint se tornará o ponto de entrada e ContainerAppCommand se tornará o comando.

Observação

Os itens de configuração ContainerEntrypoint e ContainerEntrypointArgs são preteridos a partir do .NET 8.

Importante

Isso é para usuários avançados - a maioria dos aplicativos não precisa personalizar seu ponto de entrada nesse grau. Para obter mais informações e se você quiser fornecer casos de uso para seus cenários, consulte GitHub: discussões sobre compilações de contêiner do .NET SDK.

ContainerDefaultArgs

Este item de configuração args padrão representa quaisquer argumentos substituíveis pelo usuário para seu aplicativo. Essa é uma boa maneira de fornecer padrões que seu aplicativo pode precisar executar de uma forma que facilite a inicialização, mas ainda assim fácil de personalizar.

A configuração ContainerDefaultArgs tem uma única propriedade Include, que representa a opção ou argumento a ser aplicado ao comando ContainerAppCommand.

<ItemGroup>
  <!-- Assuming the ContainerAppCommand defined above,
       this would be the way to force the database to update.
  -->
  <ContainerDefaultArgs Include="database" />
  <ContainerDefaultArgs Include="update" />

  <!-- This is the shorthand syntax for the same idea -->
  <ContainerDefaultArgs Include="database;update" />
</ItemGroup>

ContainerEnvironmentVariable

O nó da variável de ambiente do contêiner permite adicionar variáveis de ambiente ao contêiner. As variáveis de ambiente são acessíveis imediatamente à aplicação a correr no contentor e são frequentemente usadas para alterar o comportamento em tempo de execução da aplicação em execução.

O nó ContainerEnvironmentVariable tem dois atributos:

  • Include: O nome da variável de ambiente.
  • Value: O valor da variável de ambiente.
<ItemGroup>
  <ContainerEnvironmentVariable Include="LOGGER_VERBOSITY" Value="Trace" />
</ItemGroup>

Para obter mais informações, consulte as variáveis de ambiente .NET .

Observação

Atualmente, não é possível definir variáveis de ambiente da CLI do .NET ao publicar uma imagem de contêiner. Para obter mais informações, consulte GitHub: compilações de contêiner do SDK do .NET.

ContainerPort

A porta do contêiner adiciona portas TCP (Transmission Control Protocol) ou UDP (User Datagram Protocol) à lista de portas conhecidas para o contêiner. Isso permite que tempos de execução de contêineres, como o Docker, mapeiem essas portas para a máquina host automaticamente. Isso geralmente é usado como documentação para o contêiner, mas também pode ser usado para habilitar o mapeamento automático de portas.

O nó ContainerPort tem dois atributos:

  • Include: O número da porta a ser exposta.
  • Type: O padrão é tcp, os valores válidos são tcp ou udp.
<ItemGroup>
    <ContainerPort Include="80" Type="tcp" />
</ItemGroup>

A partir do .NET 8, o ContainerPort é inferido quando não é fornecido explicitamente com base em várias variáveis de ambiente ASP.NET bem conhecidas:

  • ASPNETCORE_URLS
  • ASPNETCORE_HTTP_PORTS
  • ASPNETCORE_HTTPS_PORTS

Se essas variáveis de ambiente estiverem presentes, seus valores serão analisados e convertidos em mapeamentos de porta TCP. Essas variáveis de ambiente são lidas da imagem base, se presente, ou das variáveis de ambiente definidas em seu projeto através de itens ContainerEnvironmentVariable. Para obter mais informações, consulte ContainerEnvironmentVariable.

ContainerPublishInParallel

Para contêineres multi-RID, certos tipos de projeto (como Blazor WebAssembly) podem encontrar condições de corrida de construção. Para resolver isso, a partir das versões 8.0.408, 9.0.300 e 10.0 do SDK do .NET, você pode controlar o paralelismo do processo de publicação usando a ContainerPublishInParallel propriedade. Por padrão, a publicação ocorre em paralelo para cada Identificador de Tempo de Execução (RID). Definir essa propriedade para garantir a publicação sequencial, o que aumenta a false estabilidade, mas pode levar mais tempo.

<PropertyGroup>
  <ContainerPublishInParallel>false</ContainerPublishInParallel>
</PropertyGroup>

Para obter mais informações sobre publicação multi-RID, consulte ContainerRuntimeIdentifier(s).

ContainerUser

A propriedade de configuração do usuário controla o usuário padrão no qual o contêiner é executado. Isso geralmente é usado para executar o contêiner como um usuário não-root, o que é uma prática recomendada para segurança. Há algumas restrições para essa configuração estar ciente:

  • Ele pode assumir várias formas: nome de usuário, IDs de usuário do linux, nome do grupo, ID do grupo do linux, username:groupnamee outras variantes de ID.
  • Não há nenhuma verificação de que o usuário ou grupo especificado existe na imagem.
  • Alterar o usuário pode alterar o comportamento do aplicativo, especialmente em relação a coisas como permissões do sistema de arquivos .

O valor padrão deste campo varia de acordo com o TFM do projeto e o sistema operacional de destino:

  • Se você estiver direcionando o .NET 8 ou superior e usando as imagens de tempo de execução da Microsoft, então:
    • no Linux, o app de usuário sem raiz é usado (embora seja referenciado por seu ID de usuário)
    • no Windows, o ContainerUser de usuário sem raiz é usado
  • Caso contrário, nenhum ContainerUser padrão será usado
<PropertyGroup>
  <ContainerUser>my-existing-app-user</ContainerUser>
</PropertyGroup>

Dica

A variável de ambiente APP_UID é usada para definir informações do usuário em seu contêiner. Esse valor pode vir de variáveis de ambiente definidas em sua imagem base (como as imagens do Microsoft .NET) ou você mesmo pode defini-lo por meio da sintaxe ContainerEnvironmentVariable.

Para configurar seu aplicativo para ser executado como um usuário raiz, defina a propriedade ContainerUser como root. No arquivo de projeto, adicione o seguinte:

<PropertyGroup>
  <ContainerUser>root</ContainerUser>
</PropertyGroup>

Como alternativa, você pode definir esse valor ao chamar dotnet publish a partir da linha de comando:

dotnet publish -p ContainerUser=root

ContainerWorkingDirectory

O nó do diretório de trabalho do contêiner controla o diretório de trabalho do contêiner, o diretório no qual os comandos são executados se nenhum outro comando for executado.

Por padrão, o valor do diretório /app é usado como o diretório de trabalho.

<PropertyGroup>
    <ContainerWorkingDirectory>/bin</ContainerWorkingDirectory>
</PropertyGroup>

Sinalizadores que controlam o destino da imagem gerada

As propriedades a seguir controlam onde a imagem de contêiner gerada é armazenada ou publicada:

ContainerArchiveOutputPath

Para criar uma imagem de contêiner dentro de um arquivo tar.gz , use a ContainerArchiveOutputPath propriedade. Esse recurso é útil se o fluxo de trabalho não for simples e exigir que você, por exemplo, execute uma ferramenta de digitalização sobre suas imagens antes de enviá-las. Depois que o arquivo é criado, você pode movê-lo, digitalizá-lo ou carregá-lo em uma cadeia de ferramentas local do Docker.

Para publicar em um arquivo, adicione a propriedade ContainerArchiveOutputPath ao comando dotnet publish, por exemplo:

dotnet publish \
  -p PublishProfile=DefaultContainer \
  -p ContainerArchiveOutputPath=./images/sdk-container-demo.tar.gz

Você pode especificar um nome de pasta ou um caminho com um nome de arquivo específico. Se você especificar o nome da pasta, o nome do arquivo gerado para o arquivo de imagem será nomeado $(ContainerRepository).tar.gz. Esses arquivos podem conter várias tags dentro deles, apenas como um único arquivo é criado para todos os ContainerImageTags.

ContainerRegistry

A propriedade do registro de contêiner controla o registro de destino, o local para o qual a imagem recém-criada deve ser enviada. Por padrão, ele é enviado por push para o daemon Docker local, mas você também pode especificar um registro remoto. Ao usar um registro remoto que requer autenticação, você autentica usando os mecanismos de docker login conhecidos. Para obter mais informações, consulte a autenticação em registros de contêiner para obter mais detalhes. Para obter um exemplo concreto de uso dessa propriedade, considere o seguinte exemplo XML:

<PropertyGroup>
    <ContainerRegistry>registry.mycorp.com:1234</ContainerRegistry>
</PropertyGroup>

Essa ferramenta oferece suporte à publicação em qualquer registro que ofereça suporte à API HTTP V2 do Registro do Docker. Isto inclui os seguintes registos explicitamente (e provavelmente muitos mais implicitamente):

Para obter notas sobre como trabalhar com estes registos, consulte as notas específicas do registo .

LocalRegistry

A LocalRegistry propriedade MSBuild especifica as ferramentas de contêiner local a serem usadas ao enviar por push para fontes locais. Os valores suportados são docker e podman. Se não estiver definido, o SDK determinará a ferramenta com base na disponibilidade:

  • Se ambos docker existirem podman , e docker for um alias para podman, então podman é usado.
  • Se apenas docker existir, docker é usado.
  • Se apenas podman existir, podman é usado.
  • Se nenhum dos dois existir, um erro é lançado.

Para definir explicitamente a ferramenta de registro local, use a seguinte configuração:

<PropertyGroup>
  <LocalRegistry>podman</LocalRegistry>
</PropertyGroup>

Configuração de nomenclatura de imagem de contêiner

As imagens de contêiner seguem uma convenção de nomenclatura específica. O nome da imagem é composto por várias partes, o registro, porta opcional, repositório e tag opcional e família.

REGISTRY[:PORT]/REPOSITORY[:TAG[-FAMILY]]

Por exemplo, considere o nome da imagem mcr.microsoft.com/dotnet/runtime:8.0-alpine totalmente qualificado:

  • mcr.microsoft.com é o registro (e, neste caso, representa o registro de contêiner da Microsoft).
  • dotnet/runtime é o repositório (mas alguns consideram isso o user/repository).
  • 8.0-alpine é a tag e a família (a família é um especificador opcional que ajuda a desambiguar o empacotamento do sistema operacional).

Algumas propriedades descritas nas seções a seguir correspondem ao gerenciamento de partes do nome da imagem gerada. Considere a tabela a seguir que mapeia a relação entre o nome da imagem e as propriedades de compilação:

Parte do nome da imagem Propriedade MSBuild Valores de exemplo
REGISTRY[:PORT] ContainerRegistry mcr.microsoft.com:443
PORT ContainerPort :443
REPOSITORY ContainerRepository dotnet/runtime
TAG ContainerImageTag 8.0
FAMILY ContainerFamily -alpine

Rótulos de contêiner padrão

Os rótulos são frequentemente usados para fornecer metadados consistentes em imagens de contêiner. As ferramentas de contêiner integradas fornecem alguns rótulos padrão para aumentar a qualidade das imagens geradas. Toda a geração de rótulos padrão pode ser desabilitada definindo ContainerGenerateLabels como false. Além disso, cada rótulo padrão tem um sinalizador de ativação individual que pode ser definido para false desabilitar esse rótulo específico.

Sempre que possível, as propriedades existentes do MSBuild fornecem os valores para esses rótulos. Outras propriedades permitem o controle explícito de seus valores.

Anotação Valor predefinido Nome da propriedade dedicada Nome da propriedade de fallback Nome da propriedade ativada Observações
org.opencontainers.image.created e org.opencontainers.artifact.created O formato RFC 3339 do UTC DateTime atual ContainerGenerateLabelsImageCreated
org.opencontainers.artifact.description e org.opencontainers.image.description ContainerDescription Description ContainerGenerateLabelsImageDescription
org.opencontainers.image.authors ContainerAuthors Authors ContainerGenerateLabelsImageAuthors
org.opencontainers.image.url ContainerInformationUrl PackageProjectUrl ContainerGenerateLabelsImageUrl
org.opencontainers.image.documentation ContainerDocumentationUrl PackageProjectUrl ContainerGenerateLabelsImageDocumentation
org.opencontainers.image.version ContainerVersion PackageVersion ContainerGenerateLabelsImageVersion
org.opencontainers.image.vendor ContainerVendor ContainerGenerateLabelsImageVendor
org.opencontainers.image.licenses ContainerLicenseExpression PackageLicenseExpression ContainerGenerateLabelsImageLicenses
org.opencontainers.image.title ContainerTitle Title ContainerGenerateLabelsImageTitle
org.opencontainers.image.base.name ContainerBaseImage ContainerGenerateLabelsImageBaseName
org.opencontainers.image.base.digest ContainerGenerateLabelsImageBaseDigest Este é o resumo SHA da imagem base escolhida. Disponível a partir do .NET SDK 9.0.100 em diante.
org.opencontainers.image.source PrivateRepositoryUrl ContainerGenerateLabelsImageSource Só escrito se PublishRepositoryUrl for true. Também depende da infraestrutura Sourcelink como parte da compilação.
org.opencontainers.image.revision SourceRevisionId ContainerGenerateLabelsImageRevision Só escrito se PublishRepositoryUrl for true. Também depende da infraestrutura Sourcelink como parte da compilação.

Ver também

  • Last updated on