Partilhar via

Contentorizar uma aplicação .NET Core

  • Artigo

Aplica-se a: Windows Server 2025, Windows Server 2022, Windows Server 2019, Windows Server 2016

Este tópico descreve como empacotar um aplicativo .NET de exemplo existente para implantação como um contêiner do Windows, depois de configurar seu ambiente conforme descrito em Introdução: Preparar o Windows para contêinerese executar seu primeiro contêiner conforme descrito em Executar seu primeiro contêiner do Windows.

Você também precisará do sistema de controle de origem Git instalado no seu computador. Para instalá-lo, visite Git.

Clone o código de exemplo do GitHub

Todo o código-fonte de exemplo de contêiner é mantido sob o repositório git Virtualization-Documentation em uma pasta chamada windows-container-samples.

  1. Abra uma sessão do PowerShell e altere os diretórios para a pasta na qual você deseja armazenar esse repositório. (Outros tipos de janela de prompt de comando também funcionam, mas nossos comandos de exemplo usam o PowerShell.)

  2. Clone o repositório no seu diretório de trabalho atual:

    git clone https://github.com/MicrosoftDocs/Virtualization-Documentation.git

  3. Navegue até o diretório de exemplo encontrado em Virtualization-Documentation\windows-container-samples\asp-net-getting-started e crie um Dockerfile, usando os comandos a seguir.

    Um Dockerfile é como um makefile: é uma lista de instruções que indicam ao motor de containers como construir a imagem do container.

    # Navigate into the sample directory
Set-Location -Path Virtualization-Documentation\windows-container-samples\asp-net-getting-started

# Create the Dockerfile for our project
New-Item -Name Dockerfile -ItemType file

Escrever o Dockerfile

Abra o Dockerfile que você acabou de criar com qualquer editor de texto que você gosta e, em seguida, adicione o seguinte conteúdo:

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Vamos dividi-lo linha por linha e explicar o que cada instrução faz.

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

O primeiro grupo de linhas declara a partir de qual imagem base usaremos para construir nosso contêiner em cima. Se o sistema local ainda não tiver essa imagem, o docker tentará buscá-la automaticamente. O mcr.microsoft.com/dotnet/core/sdk:2.1 vem embalado com o SDK do .NET Core 2.1 instalado, portanto, está preparado para criar projetos ASP .NET Core destinados à versão 2.1. A próxima instrução altera o diretório de trabalho em nosso contêiner para ser /app, para que todos os comandos seguintes a este sejam executados sob este contexto.

COPY *.csproj ./
RUN dotnet restore

Em seguida, essas instruções copiam os arquivos .csproj para o diretório /app do contêiner build-env. Depois de copiar este ficheiro, o .NET irá lê-lo para depois procurar todas as dependências e ferramentas necessárias para o nosso projeto.

COPY . ./
RUN dotnet publish -c Release -o out

Depois que o .NET tiver puxado todas as dependências para o contêiner build-env, a próxima instrução copiará todos os arquivos de origem do projeto para o contêiner. Em seguida, dizemos ao .NET para publicar nosso aplicativo com uma configuração de versão e especificar o caminho de saída.

A compilação deve ser bem-sucedida. Agora temos de construir a imagem final.

Dica

Este guia de início rápido cria um projeto .NET core a partir do código-fonte. Ao criar imagens de contêiner, é uma boa prática incluir apenas carga útil de produção e suas dependências na imagem de contêiner. Não queremos que o SDK do núcleo do .NET seja incluído em nossa imagem final porque só precisamos do tempo de execução do núcleo do .NET, então o dockerfile é gravado para usar um contêiner temporário que é empacotado com o SDK chamado build-env para criar o aplicativo.

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Como nosso aplicativo é ASP.NET, especificamos uma imagem com esse tempo de execução incluído. Em seguida, copiamos todos os arquivos do diretório de saída do nosso contêiner temporário para o contêiner final. Configuramos nosso contêiner para ser executado com nosso novo aplicativo como ponto de entrada quando o contêiner for iniciado

Nós escrevemos o dockerfile para realizar uma compilação de vários estágios . Quando o dockerfile é executado, ele usa o contêiner temporário, build-env, com o SDK do .NET core 2.1 para criar o aplicativo de exemplo e, em seguida, copiar os binários de saída para outro contêiner contendo apenas o tempo de execução do .NET core 2.1 para que minimizemos o tamanho do contêiner final.

Criar e executar o aplicativo

Com o Dockerfile escrito, podemos apontar o Docker para o nosso Dockerfile e dizer-lhe para construir e, em seguida, executar a nossa imagem:

  1. Em uma janela de prompt de comando, navegue até o diretório onde o dockerfile reside e, em seguida, execute o comando docker build para construir o contêiner a partir do Dockerfile.

    docker build -t my-asp-app .

  2. Para executar o contêiner recém-construído, execute o comando docker run.

    docker run -d -p 5000:80 --name myapp my-asp-app

    Vamos dissecar este comando:

    • -d diz ao Docker para executar o contêiner 'separado', o que significa que nenhum console está conectado ao console dentro do contêiner. O contêiner é executado em segundo plano.
    • -p 5000:80 diz ao Docker para mapear a porta 5000 no host para a porta 80 no contêiner. Cada contêiner recebe seu próprio endereço IP. O ASP .NET escuta por padrão na porta 80. O mapeamento de portas nos permite ir para o endereço IP do host na porta mapeada e o Docker encaminhará todo o tráfego para a porta de destino dentro do contêiner.
    • --name myapp diz ao Docker para dar a esse contêiner um nome conveniente para consulta (em vez de ter que procurar o ID do contêiner atribuído em tempo de execução pelo Docker).
    • my-asp-app é a imagem que queremos que o Docker execute. Esta é a imagem do contêiner produzida como culminar do processo docker build.

  3. Abra um navegador da Web e navegue até http://localhost:5000 para ver seu aplicativo em contêiner.

    ASP.NET página da Web Core, executada a partir do localhost em um contêiner

Próximos passos

  1. A próxima etapa é publicar seu aplicativo Web ASP.NET em contêiner em um registro privado usando o Registro de Contêiner do Azure. Isso permite que você o implante em sua organização.

    Criar um registro de contêiner privado

    Quando você chegar à seção onde você enviar sua imagem de contêiner para ode registro , especifique o nome do aplicativo de ASP.NET que você acabou de empacotar (my-asp-app) junto com seu registro de contêiner (por exemplo: contoso-container-registry):

    docker tag my-asp-app contoso-container-registry.azurecr.io/my-asp-app:v1

    Para ver mais exemplos de aplicações e os respetivos dockerfiles associados, veja amostras de contêiner adicionais.

  2. Depois de publicar seu aplicativo no registro de contêiner, a próxima etapa é implantar o aplicativo em um cluster Kubernetes criado com o Serviço Kubernetes do Azure.

    Criar um cluster Kubernetes