Colocar um aplicativo .NET Core em contêiner

Artigo
03/31/2023

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

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

Você também precisará ter o sistema de controle do código-fonte Git instalado no computador. Para instalá-lo, visite Git.

Clonar o código de exemplo do GitHub

Todo o código-fonte de exemplo do contêiner fica no repositório Git Virtualization-Documentation (conhecido informalmente como repo), em uma pasta chamada windows-container-samples.

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

Clone o repositório para seu diretório de trabalho atual:

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

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 é semelhante a um makefile – é uma lista de instruções que dizem 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
```

Escrever o Dockerfile

Abra o Dockerfile que acabou de criar usando o editor de texto que desejar 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 examiná-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 determina sobre qual imagem base criaremos nosso contêiner. Se o sistema local não tiver essa imagem ainda, o docker tentará obtê-la automaticamente. O mcr.microsoft.com/dotnet/core/sdk:2.1 vem empacotado com o SDK do .NET Core 2.1 instalado, portanto, é capaz de executar a tarefa de criar projetos ASP .NET Core voltados para a versão 2.1. A instrução a seguir altera o diretório de trabalho em nosso contêiner para /app, para que todos os comandos depois desse sejam 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 fará a leitura dele e buscará todas as dependências e ferramentas de que o projeto precisa.

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

Depois que o .NET tiver efetuado pull de todas as dependências para o contêiner build-env, a instrução seguinte copiará todos os arquivos de origem do projeto para o contêiner. Em seguida, instruiremos o .NET a publicar o aplicativo com uma configuração de versão e especificaremos o caminho de saída.

A compilação deverá ser bem-sucedida. Agora, precisamos criar a imagem final.

Dica

Este guia de início rápido cria um projeto do .NET Core da origem. Ao criar imagens de contêiner, é uma melhor prática incluir apenas a carga de produção e suas dependências na imagem de contêiner. Não queremos que o SDK do .NET Core seja incluído em nossa imagem final porque precisamos apenas do runtime do .NET Core, portanto, o dockerfile é escrito de modo a 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. Então, copiamos todos os arquivos do diretório de saída do contêiner temporário no contêiner final. Configuramos nosso contêiner para ser executado com nosso novo aplicativo como seu ponto de entrada quando o contêiner é iniciado

Escrevemos o dockerfile para executar uma compilação em vários estágios. Quando o dockerfile for executado, ele usará 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 que contém apenas o runtime do .NET Core 2.1, de modo que minimizamos o tamanho do contêiner final.

Compilar e executar o aplicativo

Com o Dockerfile escrito, podemos apontar o Docker para nosso Dockerfile e pedir que ele crie e, em seguida, execute a imagem:

Em uma janela de prompt de comando, navegue até o diretório em que o dockerfile reside e execute o comando docker build para criar o contêiner usando o Dockerfile.
```
docker build -t my-asp-app .
```
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 detalhar este comando:
- -d instrui o Docker a executar o contêiner “desanexado”, o que significa que nenhum console é 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 o próprio endereço IP. O ASP.NET escuta por padrão na porta 80. O mapeamento de portas 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 dar a esse contêiner um nome conveniente com o qual fazer consultas (para que não haja necessidade de buscar a ID do contêiner atribuída no runtime 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.
Abra um navegador da Web e navegue até http://localhost:5000 para ver seu aplicativo conteinerizado, conforme mostrado nesta captura de tela:

Próximas etapas

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 implantá-lo em sua organização.

Criar um registro de contêiner privado

Quando chegar à seção em que você efetua push da imagem de contêiner para o registro, especifique o nome do aplicativo ASP.NET que você acabou de empacotar (my-asp-app) junto com o 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, confira amostras de contêiner adicionais.
Depois de publicar o aplicativo no registro de contêiner, a etapa seguinte seria implantar o aplicativo em um cluster do Kubernetes criado com o Serviço de Kubernetes do Azure.

Criar cluster do Kubernetes

Compartilhar via