Compartilhar via

Conteinerizar um aplicativo .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 do código-fonte Git instalado em seu computador. Para instalá-lo, visite Git.

Clonar 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 do prompt de comando também funcionam, mas nossos comandos de exemplo usam o PowerShell.)

  2. Clone o repositório no 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 informam ao mecanismo de contêiner como criar a imagem de contêiner.

    # 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

Gravar o Dockerfile

Abra o Dockerfile que você acabou de criar com o editor de texto desejado e 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 a 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 qual imagem base usaremos para criar nosso contêiner na parte superior. 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 empacotado com o SDK do .NET Core 2.1 instalado, portanto, está preparado para criar projetos do ASP .NET Core visando a versão 2.1. A próxima instrução altera o diretório de trabalho em nosso contêiner para ser /app, portanto, todos os comandos após este são executados nesse 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 esse arquivo, o .NET lerá o arquivo e depois irá buscar todas as dependências e ferramentas necessárias para o nosso projeto.

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

Depois que o .NET puxar 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, instruímos o .NET a publicar nosso aplicativo com uma configuração de release e especificar o caminho de saída.

A compilação deve ser bem-sucedida. Agora, devemos criar a imagem final.

Dica

Este início rápido cria um projeto do .NET Core de origem. Ao criar imagens de contêiner, é uma boa prática incluir apenas o conteúdo de produção e suas dependências na imagem do contêiner. Não queremos que o SDK do .NET Core seja incluído em nossa imagem final porque só precisamos do runtime do .NET Core, portanto, o dockerfile é gravado para usar um contêiner temporário que é empacotado com o SDK chamado build-env para compilar 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 runtime incluído. Em seguida, copiamos todos os arquivos do diretório de saída do contêiner temporário em nosso contêiner final. Configuramos nosso contêiner para ser executado com nosso novo aplicativo como seu ponto de entrada quando o contêiner for iniciado

Escrevemos o dockerfile para executar uma compilação de várias fases. 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 copiar os binários gerados em outro contêiner contendo apenas o runtime do .NET Core 2.1 para que minimizamos o tamanho do contêiner final.

Compilar e executar o aplicativo

Com o Dockerfile pronto, podemos indicar ao Docker o nosso Dockerfile e instruí-lo a construir e, depois, executar nossa imagem.

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

    docker build -t my-asp-app .

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

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

    Vamos dissecar este comando:

    • -d informa ao Docker para executar o contêiner "desanexado", o que significa que nenhum console está conectado ao console dentro do contêiner. O contêiner é executado em segundo plano.
    • -p 5000:80 instrui o Docker a mapear a porta 5000 no host para a porta 80 no contêiner. Cada contêiner obtém seu próprio endereço IP. O ASP.NET ouve por padrão na porta 80. O mapeamento de porta nos permite acessar 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 instrui o Docker a atribuir a esse contêiner um nome conveniente para consulta (em vez de precisar pesquisar 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. Essa é a imagem de contêiner produzida como a culminação do processo de docker build.

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

    página da Web do O ASP.NET Core, em execução no localhost em um contêiner

Próximas etapas

  1. A próxima etapa é publicar seu aplicativo Web ASP.NET em contêineres 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 para enviar por push sua imagem de contêiner no registro, especifique o nome do aplicativo ASP.NET que você acabou de empacotar (my-asp-app) no 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 aplicativos e seus dockerfiles associados, consulte os exemplos adicionais de contêiner .

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

    Criar um cluster do Kubernetes