Docker - Usando imagens da ASP .NET Core 2.2

No artigo de hoje veremos como usar as imagens base da ASP .NET Core 2.2 para criar imagens customizadas usando o Dockerfile.

Já estão disponíveis as novas versões das imagens para o SDK da .NET Core 2.2 no Docker Hub.

Acessando o link : https://hub.docker.com/_/microsoft-dotnet-core teremos o links para os repositórios:

Acessando o repositório do .NET Core SDK no link https://hub.docker.com/_/microsoft-dotnet-core-sdk/ temos as informações a seguir:

Tags em destaques

Esta imagem contém o .NET Core SDK que é composto de 3 partes:

  1. .NET Core CLI
  2. .NET Core
  3. ASP.NET Core

Utilize esta imagem para o processo de desenvolvimento.

Fazendo um resumo para o .NET Core 2.2 e ASP .NET Core 2.2 temos as seguintes imagens:

Imagem Descrição
microsoft/dotnet:2.2-sdk Contém o SDK Completo
microsoft/dotnet:2.2-sdk-alpine: Contém o SDK Completo usando a distro Alpine
microsoft/dotnet:2.2-aspnetcore-runtime Contém o runtime da Asp.Net Core
microsoft/dotnet:2.2-aspnetcore-runtime-alpine Contém o runtime da Asp.Net Core usando a distro Alpine

Nota: O Alpine é uma distribuição(distro) Linux simples, eficiente e leve o que torna as imagens que usa esta distro menores.

Na figura veja as imagens baixadas localmente usando o comando : docker pull <nome_imagem>

Observe o tamanho das imagens do SDK e do runtime, e, note também que as imagens com Alpine são um pouco menores.

Vamos usar essas imagens como base para criar imagens customizadas e a seguir os contêineres usando o arquivo Dockerfile e o processo de build:

As etapas que iremos cumprir são:

  1. Criar uma aplicação ASP .NET Core 2.2
  2. Criar um Dockerfile para criar uma imagem customizada contendo a nossa aplicação criada no item anterior com base na imagem base
  3. Criar um contêiner com base na imagem customizada

Recursos usados:

Criando uma aplicação ASP .NET Core MVC e contêinerizando a aplicação

Vamos iniciar criando uma aplicação ASP .NET Core MVC usando a ASP .NET Core 2.2 e as ferramentas da linha de comando NET CLI. 

Obs: Como estamos usando imagens .NET Core vamos usar contêineres do Linux.

Abra um terminal de comando.

A primeira coisa a fazer é verificar se o seu ambiente possui o .NET Core SDK 2.2 instalado. Para isso digite o seguinte comando :

dotnet --version

Agora posicione-se em uma pasta onde o projeto será criado. Estou usando uma pasta chamada projetos.

A seguir execute os seguintes comandos:

cd projetos
mkdir src
cd src
mkdir AspMvc1
cd AspMvc1

Esses comandos criam uma pasta AspMvc1 dentro de uma pasta src na pasta projetos.

Após se posicionar na pasta AspMvc1 digite o comando para criar o projeto ASP .NET Core MVC:

dotnet new mvc

Temos assim nosso projeto ASP .NET Core MVC criado na pasta AspMvc1.

Vamos executar o comando abaixo para testar o projeto:

dotnet run

Vemos que nossa aplicação esta em atendimento em : http://localhost:5000


Pronto nossa aplicação esta pronta e funcionando corretamente. Vamos agora publicar nossa aplicação ASP .NET Core MVC.

Estando na pasta do projeto AspMvc1 digite o comando : dotnet restore para restaurar as dependências do projeto.

A seguir publique a aplicação digitando o comando:  dotnet publish -o ./publish

Este comando empacota o aplicativo e suas dependências em uma nova pasta chamada publish.

Agora, nossa aplicação esta pronta para ser executado em qualquer lugar (ou quase em qualquer lugar).

Vamos entrar nesta pasta e digitar:

cd publish
ls
dotnet AspMvc1.dll

Nossa aplicação será executada e estará atendendo em localhost:5000.

Vamos agora criar uma imagem que contenha essa aplicação e o ambiente de execução da ASP .NET Core.

Criando uma imagem customizada usando o Dockerfile

Depois de criarmos o aplicativo, podemos criar uma imagem com nossa aplicação para depois criar um contêiner e executar o contêiner onde a aplicação estar rodando.

Para isso temos que criar um Dockerfile com as instruções necessárias para executar nosso aplicativo em qualquer lugar.

Nota : O Dockerfile é um arquivo que contém instruções passo a passo para implantar a imagem dentro do contêiner

Se você não conhece o Dockerfile nem o processo de build leia o artigo: Criando uma imagem com Dockerfile

Para criar o arquivo Dockerfile eu vou usar o Visual Studio Code.

Vamos retornar a pasta raiz que é a pasta projetos e a seguir digitar o comando:  code .

A seguir crie um arquivo chamado Dockerfile na pasta projetos com o seguinte código:

No arquivo Dockerfile definimos os comandos que serão executados para criar nossa imagem.

A primeira linha FROM microsoft/dotnet:2.2-aspnetcore:runtime vai baixar a imagem da aspnetcore do repositório do hub, para que ela realmente contenha o .NET Core e você não precise colocá-la dentro da imagem.

Na segunda linha o comando LABEL permite definir a versão e o autor da imagem. Poderiamos tere incluído uma description também.

Na terceira linha WORKDIR /app define nosso diretório de trabalho na pasta do aplicativo, dentro do container que estamos construindo.

Em seguida, precisamos copiar o conteúdo da pasta de publish para a pasta do aplicativo na imagem usando o comando COPY ./src/AspMvc1/publish

A última linha usa a instrução ENTRYPOINT ["dotnet", "AspMvc1.dll"] que executa o comando dotnet com o parâmetro AspMvc1.dll.

Saindo do VS Code e retornando para pasta projetos, vamos exibir o arquivo e listar o seu contéudo:comando:

ls  Dockerfile
cat Dockerfile

Agora podemos partir para a terceira etapa e criar a imagem usando o comando build.

Criando a imagem usando o processo build

Com o terminal aberto e estando na pasta projetos vamos digitar o comando para processar o Dockerfile:

docker build -t aspmvc1-mac .

Este comando diz ao docker “construa a imagem, com o nome aspnmvc1-mac no diretório raiz."

Você verá no log como o docker é executado passo a passo no Dockerfile:

Emitindo o comando para visualizar as imagens temos:

docker images

Vemos a nossa imagem aspmvc1-mac criada com 264 MB e como não tagueamos a imagem a tag atribuída foi latest.

Agora temos uma imagem e podemos criar um contêiner onde teremos nossa aplicação ASP .NET Core MVC em execução , e, ele vai poder ser executado em qualquer ambiente que contenha o Docker.

Criando o contêiner a partir da nossa imagem

Podemos agora criar um contêiner com base em nossa imagem aspmvc1-mac:latest criada.

Emitindo o comando:

docker container run -p 5000:80 aspmvc1-mac:latest

Veremos o contêiner ser criado e a nossa aplicação ser executada no contêiner:

Abrindo o navegador em localhost:5000 iremos obter o resultado abaixo:

Vimos  assim todo o processo de criação da aplicação ASP .NET Core, da imagem personalizada e do contêiner usando o Docker.

Bem-aventurados os limpos de coração, porque eles verão a Deus;
Bem-aventurados os pacificadores, porque eles serão chamados filhos de Deus;
Mateus 5:8,9

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti