Nesse post irei abordar os passos para configuração do ambiente de desenvolvimento .Net Core no Linux. A distribuição utilizada será o Debian 9 e usaremos o Docker para subir um contêiner e o docker-compose para facilitar esse processo.
Vou supor que você já tenha um conhecimento básico do Docker, para isso existem diversos tutoriais de introdução e a documentação oficial. Se preferir uma introdução em vídeo uma boa dica é o canal Linux Tips que tem ótimos vídeos sobre Docker inclusive uma excelente e amigável introdução ao Docker.
Para iniciar vamos criar um diretório chamado “debian-core” e nele criaremos os arquivos Dockerfile e docker-compose.yml:
A primeira linha do arquivo Dockerfile define qual contêiner vamos utilizar:
FROM debianEm seguida usamos o comando RUN para executar um comando durante a criação do nosso contêiner. Vamos executar o apt-get update para atualizar a lista de repositórios do Debian. O parâmetro -y serve para responder yes para as confirmações do apt-get instalando tudo automaticamente sem uma confirmação do usuário:
RUN apt-get -y updateEm seguida vamos informar as dependências para o .Net Core:
RUN apt-get -y install curl libunwind8 gettext apt-transport-https gnupg apt-utilsSegue uma breve explicação de cada biblioteca:
libunwind8 => biblioteca que determina a cadeia de chamada de um programa(tempo de execução).
gettext => biblioteca do Projeto GNU que faz a internacionalização de softwares.
apt-transport-https => Permite o uso de repositórios https no arquivo /etc/apt/sources.list para que os gerenciadores de pacotes que usam a
biblioteca libapt-pkg possam acessar os metadados e pacotes disponíveis em repositórios que usam o Protocolo de Transferência de Hipertexto Seguro(HTTPS).
gnupg => GNU Privacy Guard é uma alternativa GPL ao aplicativo PGP de criptografia.
apt-utils => Pacote com utilitários em linha de comando relativos a gestão de pacotes com APT.
Segue o Dockerfile completo com comentários explicando cada linha:
# Informa ao Docker qual container iremos utilizar
FROM debian
# Executa o comando apt-get -y update na criação do container
RUN apt-get -y update
# Instala as dependencias para a instalação do .Net Core
RUN apt-get -y install curl libunwind8 gettext apt-transport-https gnupg apt-utils
# usa o curl para baixar o chave publica do repositorio. Em seguida
# envia a saida do curl (usando o pipe | ) para o gpg empacotar o formato ASCII e gerar o arquivo microsoft.gpg
RUN curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
# move o arquivo gerado para a pasta de repositórios confiáveis do apt
RUN mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
# Adiciona o repositório do .Net Core ao source list
RUN sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-debian-stretch-prod stretch main" > /etc/apt/sources.list.d/dotnetdev.list'
# atualiza novamente os repositórios
RUN apt-get -y update
# faz a instalação do .Net Core
RUN apt-get -y install dotnet-sdk-2.1.4
# exporta as variáveis de ambiente
RUN export PATH=$PATH:$HOME/dotnet
# cria o diretório codes na raiz do container
RUN mkdir -p /codes
# define o diretório codes como diretório de trabalho
# isso vai espelhar a pasta codes no diretório debian-core para a pasta codes no container
WORKDIR /codesUPDATE: 26/07/2018
Como observado pelo amigo @rogerio.fonseca, cada comando RUN no Dockfile cria uma camada diferente. O ideal seria minimizar o uso de vários comandos RUN para que não seja criado diversas camadas sem necessidade. Vou manter vários comandos para que fique mais didático, mas devemos nos atentar a esse detalhe para reduzir o tamanho da imagem gerada pelo Docker. Se quiser um detalhamento sobre as camadas criadas pelo Docker confira esse post. Para reduzir o uso de vários comandos RUN podemos fazer a concatenação dos comandos usando && como no exemplo abaixo:
RUN apt-get update && apt-get install curlO próximo passo é a criação do docker-compose.yml. o Docker Compose é uma ferramenta para definir e executar múltiplos contêineres:
O docker-compose.yml é bem simples pois não define dependência com outros contêineres.
Com os arquivos criados o próximo passo é executar o comando docker-compose build na pasta debian-core para fazer a construção do nosso contêiner. No terminal estando na pasta debian-core execute o seguinte comando:
docker-compose buildO docker-compose irá executar todos os comandos definidos no Dockerfile e terá a seguinte saída:
Com o container construído é hora de subir:
docker-compose up &O carácter & no final do comando é para fazer com que o processo execute em background deixando o terminal liberado para executar novos comandos:
Agora vamos verificar se o nosso contêiner está rodando:
docker psO comando docker ps serve para listar os contêineres que estão em execução:
Certo, tudo rodando, agora precisamos “entrar ” no container para checar se o .Net Core foi realmente instalado. Vamos usar o comando docker exec para executar uma sessão bash no contêiner:
docker exec -i -t debiancore\_debian-core\_1 /bin/bashO parâmetro -i serve para manter a entrada padrão aberta e o parâmetro -t serve para alocar uma saída padrão. Em seguida temos o nome do contêiner que queremos executar e pra finalizar o comando que será executado, nesse caso /bin/bash:
Estando no container vamos verificar a versão do .Net:
dotnet --version
Tudo funcionando. Agora vamos criar um projeto do tipo console para testar o nosso ambiente. Execute o seguinte comando no terminal do contêiner:
dotnet new console -o helloO parâmetro -o informa ao dotnet para criar os arquivos do projeto na pasta hello. Podemos ver que ao criar os arquivos no contêiner eles já são refletidos na pasta codes do nosso projeto debian-core:
O projeto do tipo console já implementa a classe Program que possui o método Main que imprime uma mensagem usando console.WriteLine.
Para executar o projeto digite dotnet run no terminal do contêiner:
dotnet run O programa irá executar e exibir a mensagem definida no console.WriteLine:
Com isso concluímos a configuração do ambiente .Net Core no Linux, sendo possível desenvolver normalmente na máquina host e executar no contêiner Linux. Qualquer dúvida deixe um comentário. Até a próxima!