Docker - Uma introdução básica - VI

 Neste artigo vou apresentar os conceitos básicos relativos ao Docker sob o ponto de vista de um desenvolvedor .NET.

Até o momento já sabemos criar contêineres a partir de imagens, compartilhar recursos de contêineres e baixar e tratar imagens. (artigo anterior)

Sabemos também que existem repositórios contendo imagens prontas que podemos baixar e usar conforme a nossa necessidade. Assim, o Docker Hub contém uma ampla variedade de imagens prontas.

Ocorre que nem sempre a imagem que desejamos usar esta pronta do jeitinho que queremos, e, muitas vezes, teremos que ter uma imagem customizada. Nestes casos não tem jeito: vamos ter que criar as nossas próprias imagens.

Veremos a seguir como podemos criar imagens.

Criando imagens usando Dockerfile

O Docker constrói imagens automaticamente lendo as instruções a partir de um arquivo texto chamado Dockerfile (esse processo é conhecido como processo de build) que contém todos os comandos em ordem necessários para criar uma imagem.

Assim, podemos criar a nossa própria imagem através do arquivo Dockerfile; ele é o responsável por criar as imagens no Docker, é nele que definimos todas as regras, informações e instruções que estarão contidas mas imagens.

Mas o que é esse tal de Dockerfile ?

O Dockerfile é um arquivo responsável por realizar a criação e construção de imagens no Docker, dentro dele são definidas instruções que o Docker vai seguir para conseguir realizar a criação de uma imagem. Essas instruções são interpretadas linha a linha pelo engine do Docker.

Para definir as regras e instruções que a imagem terá, devemos utilizar comandos que o Dockerfile entende. Pense no Dockerfile como um arquivo de lote que contém instruções/comandos com uma sintaxe definida (INSTRUÇAO argumento) que devemos seguir para que uma imagem seja criada.

Assim, uma imagem Docker consiste de camadas somente-leitura onde cada camada representa uma instrução do Dockerfile.

Para poder mostrar os comandos que o Dockerfile usa e como ele funciona, vamos usar o Dockerfile para criar uma imagem, e, depois, a partir dessa imagem, vamos criar um contêiner que, a partir do debian 8, instale e inicie o servidor web nginx.

A primeira tarefa que temos que fazer é definir o passos que vamos usar para criar a imagem.

  1. Definir uma imagem base
  2. Definir informações para a imagem
  3. Definir o nome de quem criou o arquivo
  4. Executar comandos para instalar o nginx na imagem e iniciar o nginx
  5. Expor a porta do contêiner e definir em qual porta o servidor vai atender
  6. Definir o ponto de entrada a aplicação
  7. Definir a execução de  um comando para inicializar o servidor nginx

Crie uma pasta chamada dockimg no seu host,  entre na pasta, e, crie um arquivo com o nome Dockerfile sem extensão: (Eu vou usar o VS Code para criar o arquivo Dockerfile)

Nota: O nome do arquivo tem que ser exatamente Dockerfile

mkdir dockimg
cd dockimg
code .

 

Com o Visual Studio Code aberto crie o arquivo Dockerfile e inclua o código abaixo:

Os comandos definidos no arquivo Dockerfile foram:

FROM debian:8
LABEL version="1.0.1" description="Instalar e subir nginx"
MAINTAINER macoratti@yahoo.com
RUN apt-get update && apt-get install -y nginx && apt-get clean
EXPOSE 80
ENTRYPOINT ["/usr/sbin/nginx"]
CMD ["-g","daemon off;"]

Vamos entender cada uma das instruções usadas:

FROM - Podemos definir uma imagem base através da instrução FROM seguida pelo nome da imagem que queremos utilizar;

LABEL - Permite definir informações sobre a imagem como a versão, descrição, o criador, etc.;

MAINTAINER - Permite informar quem criou o arquivo;

RUN - Permite executar comandos conhecidos pelo shell ou linux. Em nosso exemplo definimos um comando para instalar o nginx e informamos o parâmetro -y para aceitar a instalação;

EXPOSE - Expõe a porta do contêiner. A instrução não faz o mapeamento de porta, apenas deixa explícito que uma determinada porta pode ser mapeada durante a criação do container que utilizar essa imagem. (Por padrão o nginx sobe na porta 80)

 ENTRYPOINT - Define um caminho onde o comando definido em CMD deve ser executado;

CMD - Define um ou mais comandos que serão executados. Necessita da informação do ENTRYPOINT. Assim as duas instruções se complementam. Para o exemplo, a execução do comando ficaria assim:
 /usr/sbin/nginx -g daemon off;

Para o nosso exemplo estamos executando o comando para iniciar o nginx na imagem no modo iterativo.

Nota: A instrução MAINTAINER esta sendo depreciada e a informação do autor pode ser definida na instrução LABEL com a palavra maintainer.

Dessa forma já temos o arquivo Dockerfile criado para gerar a imagem. Para fazer isso usamos o comando  build e informamos o nome da imagem, a tag e um ponto(.). O comando fica assim:

docker build -t macoratti/nginx:1.0 .

onde:

docker build            -> O comando
-t                             -> Parâmetro usado para informar que a imagem pertence ao meu usuário
macoratti/nginx:1.0 -> O nome da imagem e a tag atribuída à imagem
.                               -> significa o diretório atual (pois dei o build dentro da pasta do Dockerfile)

Nota: O build não trabalha com o caminho do arquivo, apenas com o seu diretório, então é preciso informar o caminho do diretório ou, no nosso caso, como estamos no diretório onde se localiza o Dockerfile, apenas um ponto(.) para identificar que o Dockerfile está no diretório atual.

O comando docker build constrói uma imagem a partir de um Dockerfile e de um contexto. O contexto do build é o conjunto de arquivos na localização especificada PATH ou URL. O PATH é  o diretório no seu sistema de arquivos local e a URL é a localização do repositório GIT.

Obs: Um contexto é processado recursivamente, assim PATH inclui os subdiretórios e a URL inclui o repositório e seus submódulos.

 

Voltando ao host na pasta dockimg e executando o comando vemos o início do processamento acima, e, abaixo a conclusão indicando que nossa imagem foi criada com sucesso:

Exibindo as imagens: docker images

Vemos a imagem macoratti/nginx:1.0 criada com a TAG igual a 1.0, o ID, data de criação e tamanho.

Agora para concluir, podemos criar um contêiner com a nossa imagem usando o comando:

docker container create -p 8080:80 macoratti/nginx:1.0

Neste comando estamos criando o contêiner usando parâmetro -d de forma que ele será executando em segundo plano(daemon).

Para conferir basta abrir o navegador em http://localhost:8080.

Para exibir o contêiner criado em execução : docker container ps

Vemos assim o nosso contêiner criado a partir de uma imagem que geramos localmente contendo o debian e o nginx.

Depois de criar a imagem podemos subir a imagem para o Docker Hub mas para isso é preciso criar uma conta no site e fazer, login e usar o comando push para enviar a imagem.

docker login

docker push <nome_imagem>

A seguir os comandos que podemos usar no Dockerfile:

Na próxima aula vamos veremos como cria uma imagem para uma aplicação ASP .NET Core MVC.

"Com o ouvir dos meus ouvidos ouvi, mas agora te vêem os meus olhos.
Por isso me abomino e me arrependo no pó e na cinza. "
Jó 42:5,6

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 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti