C# - Primeiros passos com Docker

Hoje veremos como disponibilizar uma aplicação console criada com .Net a partir de um contêiner, mas antes vamos entender melhor o que é o Docker, o que exatamente estamos criando e ai sim criar nosso primeiro exemplo.

O que é o Docker?

"Docker é uma plataforma de software que permite criar, testar e implantar aplicativos em contêineres. Os contêineres são ambientes isolados que contêm todo o software necessário para executar um aplicativo, incluindo código, bibliotecas, dependências e configurações. Eles permitem que os aplicativos sejam executados de forma consistente em diferentes ambientes, como desenvolvimento, teste e produção."

Em resumo, com ele conseguimos empacotar aplicativos e dependências em contêineres portáteis e executá-los em qualquer máquina que possua o Docker instalado.

Podemos dizer que temos os seguintes passos para esse processo:

Criar uma imagem: possui um conjunto de informações para dizer como um container deve funcionar;
Criar um contêiner: com base em uma imagem criamos um contêiner, que é com quem interagimos para disponibilizar as aplicações criadas;

As etapas envolvidas para a criação de um contêiner são:

Criar um arquivo "Dockerfile" contendo informações sobre o ambiente a ser criado, como imagem a ser usada, qual aplicativo estará contido na mesma dentre outros;
Criar a imagem a partir de nosso "Dockerfile";
Criar um contêiner a partir de nossa imagem;
Iniciar o contêiner criado para que a aplicação contida no mesmo entre em funcionamento;

Criando a aplicação .Net

Vamos criar uma aplicação console que tem como objetivo "printar" em tela um contador, segundo a segundo. Essa aplicação pode rodar de forma indefinida ou pode rodar uma quantidade de vezes definida por parâmetro no momento da execução do mesmo.

Podemos criar a aplicação com o seguinte comando:

	
	
    dotnet new console -o DotNetDockerApp -n DotNet.Docker

Na classe "Program" teremos o seguinte código:

	
Console.WriteLine("Hello, DotNetDockerApp!");

var counter = 0;
var max = args.Length is not 0 ? Convert.ToInt32(args[0]) : -1;
while (max is -1 || counter < max)
{
    Console.WriteLine($"Counter: {++counter}");
    await Task.Delay(TimeSpan.FromMilliseconds(1_000));
}

Por fim vamos gerar uma versão "publicável" de nosso aplicativo com o comando abaixo (os arquivos devem ser gerados em "bin\Release\net7.0\publish"):

	
	
    dotnet publish -c Release

Dockerfile

Esse arquivo não possui extensão, deve ser criado no mesmo diretório do ".csproj", ele é usado pelo Docker para a criação da imagem. Para nosso exemplo esse arquivo fará o seguinte:

Baixar e usar uma imagem do sdk do .Net;
Copiar os arquivos do nosso projeto;
Restaurar pacotes e gerar uma versão release;
Baixar uma imagem para o runtime e fazer a cópia final dos artefatos compilados;

	
	
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build-env
WORKDIR /App

# Copy everything
COPY . ./
# Restore as distinct layers
RUN dotnet restore
# Build and publish a release
RUN dotnet publish -c Release -o out

# Build runtime image
FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /App
COPY --from=build-env /App/out .
ENTRYPOINT ["dotnet", "DotNet.Docker.dll"]

Criando nossa imagem e contêiner

Agora que nosso projeto está OK e já temos nosso Dockerfile basta executarmos os comandos necessários (devem ser executados no diretório onde o Dockerfile está):

	
	
    # Criar a imagem "counter-image" com base em nosso Dockerfile
    docker build -t counter-image -f Dockerfile .
    
    # Para ver as imagens disponíveis
    docker images
    
    # Agora que temos a imagem podemos criar nosso contêiner "core-counter" 
    docker create --name core-counter counter-image
    
    # Para ver todos os contêineres
    docker ps -a
    
    # Para iniciar nosso contêiner
    docker start core-counter
    
    # Para ver os contêineres em execução
    docker ps
    
    # Para ver o que nosso contêiner está fazendo podemos nos conectar a ele
    docker attach --sig-proxy=false core-counter
    
    # Se necessário podemos parar nosso contêiner
    docker stop core-counter
    
    # Se necessário podemos apagar nosso contêiner
    docker rm core-counter

Conclusão

Como podemos ver em nosso exemplo é bem simples trabalhar com contêineres e nossas aplicações .Net, ele torna a implantação de aplicativos muito mais fácil e rápida, pois não é necessário configurar manualmente cada máquina, sendo uma das principais ferramentas usadas em DevOps e implantação contínua.

PROGRAMERO

Pesquisar este blog