Baixando e inspecionando a imagem do MySQL

Vamos baixar uma imagem base do MySQL a partir do repositório, e, quando vamos adicionar um novo componente a um aplicativo em um contêiner é importante começar inspecionando a imagem para saber como ela sua volumes e forma a poder configurar os contêineres criados.

Primeiro vamos baixar a imagem do MySQL usando o comando:

docker pull mysql:8.0.0

Conferindo a imagem baixada localmente: docker images

A seguir vamos inspecionar essa imagem baixada para saber como ela trata volumes:

docker inspect mysql:8.0.0

Examinando a saida do comando vemos a seção Volumes que indica que esta imagem usa o volume para o diretório /var/lib/mysql que é o local onde o MySQL armazena os seus arquivos de dados.

Criando o Volume e o Contêiner

Para preparar o contêiner do banco de dados, vamos primeiro criar o volume usando o comando:

docker volume create --name produtosdata

Estamos criando um volume chamado produtosdata que será usado para armazenar os arquivos de dados do banco de dados MySql.

Para exibir o volume criado usamos o comando : docker volume ls

Vemos o nome do volume e o seu driver, ou seja, qual é a forma que ele deve montar o volume. Para este exemplo usamos o driver local, o driver padrão (built-in) do Docker.

Vamos agora criar e inciar um novo contêiner MySQL que usa este volume para fornecer ao contêiner o conteúdo do diretório /var/lib/mysql :

docker container run -d --name mysql -v produtosdata:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=numsey -e bind-address=0.0.0.0 mysql:8.0.0

Nota: Este comando deve ser informado em uma única linha

Verificando o contêiner cujo processo esta em execução : docker container ps

Vamos entender melhor o comando usado:

docker container run - Este comando crie e inicia um contêiner a partir de uma imagem

-d	Esse argumento informa ao Docker para executar o contêiner em segundo plano
--name mysql	Este argumento é usado para atribuir o nome mysql ao container
-e MYSQL_ROOT_PASSWORD	Este argumento define uma variável de ambiente. Neste caso, o contêiner MySQL usa a variável de ambiente MYSQL_ROOT_PASSWORD para definir a senha necessária para se conectar ao banco de dados. (numsey)
-e bind-address	Define uma variável de ambiente que assegura que o MySQL aceita requisições de todas as interfaces de rede
-v produtosdata:/var/lib/mysql	Este argumento diz ao Docker para usar um volume chamado produtosdata para fornecer o conteúdo do diretório /var/lib/mysql do contêiner.

Agora vamos examinar a informação gerada pela execução do contêiner docker do banco de dados na inicialização usando o comando :

docker logs -f mysql

Durante a inicialização do MySQL serão gravadas mensagens de log, dentre elas a mais importante é a que informa que o banco de dados esta pronto para aceitar conexões de rede como mostrado na imagem acima : ready for connections.

As inicializações subseqüentes serão muito mais rápidas porque poderão usar os arquivos que foram
criados no volume produtosdata. Quando o banco de dados estiver em execução, digite Control+C para parar de monitorar a saída e deixar o banco de dados em execução em seu contêiner em segundo plano.

Assim já temos a imagem da aplicação MVC e a imagem e o volume para o MySQL preparados.

Resta fazer o teste final criando um novo contêiner com a imagem da aplicação MVC e fazer com que ele se comunique com o banco de dados MySQL que já deve estar rodando no contêiner mysql.

Para isso vamos entender mais um pouco sobre como o Docker realiza a comunicação entre contêineres.

Quando você inicia um contêiner, o Docker conecta-o a uma rede virtual interna e atribui a ele um Internet Protocolo (IP) para que ele possa se comunicar com o servidor host e com outros contêineres na mesmo rede.

Para que o contêiner MVC converse com o banco de dados Mysql, preciso saber o endereço IP que o Docker atribuiu ao contêiner do MySQL que criamos.

Para isso vamos executar o comando abaixo e examinar a configuração do Docker para rede virtual.

docker network inspect bridge

A resposta desse comando mostrará como o Docker configurou a rede virtual e vai exibir uma seção Contêineres que mostra os contêineres conectados à rede e os endereços IP que são atribuídos a eles. Deve haver apenas um contêiner e seu campo Name deve ser mysql.

Anote o endereço do campo:   "IPV4Address" : "172.17.0.2/16"

Esse é o endereço IP que o Docker atribuiu ao contêiner. Para mim, o endereço é 172.17.0.2, mas
você pode ver um endereço diferente. Este é o endereço IP que o aplicativo MVC deve usar para se comunicar com o banco de dados MySQL.

Esse endereço pode ser fornecido ao aplicativo por meio da variável de ambiente DBHOST, que foi definida na classe Startup do aplicativo MVC no qual fizemos os ajustes.

Vamos passar esse valor quando formos criar o contêiner. Assim digite o comando abaixo para criar o contêiner da aplicação MVC:

docker container run -d --name prodmvc -p 4000:80 -e DBHOST=172.17.0.2 produtosmvc/app:1.0

Criamos um contêiner com o nome prodmvc rodando em background (-d) passando o IP(172.17.0.2) para que este contêiner se comunique com o contêiner mysql.

No comando estamos mapeando a porta 4000 no host para a porta 80 no contêiner, que é a porta que o Kestrel está usando para receber solicitações HTTP para o runtime do ASP.NET Core.

A seguir exibimos o log gerado usando o comando:  docker logs -f prodmvc

Note que os dados exibidos são os dados que definimos no método IncluiDadosDB da classe Populadb.

Vamos acessar o contêiner do mysql e executar alguns comandos nele para visualizar o banco de dados, as tabelas e exibir os dados.

Acessando o contêiner e executando alguns comandos nele:

docker container exec -it mysql /bin/bash

Entramos no contêiner e digitamos o comando para fazer o login no Mysql: mysql -u root -p

Após informar a senha(numsey) digitamos o comando para exibir os bancos de dados existentes:

show databases;

Vemos exibido o banco de dados lojadb usado pela aplicação. Logo ele foi criado com sucesso via Migrations.

A seguir acessamos o banco de dados lojadb:  use lojadb

Exibimos as tabelas do banco :  show tables;

Exibimos o conteúdo da tabela Produtos: select * from Produtos;

Assim vemos que os dados foram criados no volume produtosdata via contêiner mysql que foi acessado pelo contêiner onde esta rodando nossa aplicação MVC.

Conclusão: Criamos um contêiner para uma aplicação ASP .NET Core MVC que acessa dados e realiza as operações CRUD em um banco de dados MySQL que esta em outro contêiner e usa um volume de dados separado.

Acompanhe a introdução ao Docker nesta série de artigos sobre o assunto.

"E disse-lhe um: Senhor, são poucos os que se salvam? E ele lhe respondeu:
Porfiai por entrar pela porta estreita; porque eu vos digo que muitos procurarão entrar, e não poderão."
Lucas 13:23,24