Docker-ing Simplificado para Data Science – Parte 1

Prathamesh Sarang Blocked Desbloquear Seguir Seguindo 25 de abril de 2017

Fonte: Homepage do Docker

A situação

Como entusiastas da Data Scientist / Data Analysts / Data Science, somos de longe uma versão mais desordenada de nossas peças de engenharia de software. Nós gostamos de soluções rápidas e sujas. Base de código que às vezes põe uma pizza de queijo de ruptura dupla para envergonhar (yum embora!).

Nós gostamos de experimentar, mudar as coisas na hora e obter os resultados o mais rápido possível… porque os prazos sacodem a cabeça . Tudo isso aumenta a bagunça que já é – dependências, pacotes obscuros e problemas dependentes da plataforma. random.seed(4) o mesmo experimento requer mais do que apenas escrever random.seed(4) , e aí vêm os problemas clássicos:

"OK! Mas isso correu no meu sistema ”

“Eu enviei todo script de código, dados e outras coisas. Estranho eu não perdi nada.

“Muito preguiçoso para instalar tudo do zero, odeio o Linux / Windows / Mac”

“Não consigo instalar o pacote que você usou, você pode me ajudar?”

E se eu lhe dissesse que, como Cientista de Dados, alguém pode facilmente resolver tudo isso? Docker é a resposta!

Haverá uma seção de leitores que estaria pensando: “Docker é louco! Apenas o pessoal do DevOps o conhece e sai! ” . É verdade em alguns aspectos, mas se houver uma maneira de padronizar nosso fluxo de trabalho de ciência de dados e ser produtivo, por que não experimentá-lo. Saber apenas um pouco do Docker seria suficiente como ponto de partida.

O que é o Docker?

De acordo com o site oficial do Docker:

O Docker é a plataforma de contêiner de software líder mundial. Os desenvolvedores usam o Docker para eliminar problemas "funciona na minha máquina" ao colaborar no código com colegas de trabalho. Os operadores usam o Docker para executar e gerenciar aplicativos lado a lado em contêineres isolados para obter melhor densidade de computação. As empresas usam o Docker para construir pipelines de entrega de software ágil para enviar novos recursos com mais rapidez, segurança e confiança para os aplicativos Linux e Windows Server.

O Docker nos fornece um contêiner isolado, no qual podemos adicionar todas as coisas que precisamos para que o nosso experimento seja executado. Poderíamos também criar um aplicativo da web completo que possa ser usado como um grau de produção. Portanto, desde os experimentos até os aplicativos de produção, o Docker fornece um bom meio para lançar nossos aplicativos de Ciência de Dados no mundo real.

Para aprender o Docker, precisamos entender as terminologias e ferramentas oferecidas e o que podemos fazer com isso.

Terminologia do Docker:

  1. Contêineres do Docker: virtualização de nível de usuário pequeno (isolamento) que ajuda a instalar, criar e executar seu código / fluxo de trabalho. Todo o código seria executado continuamente nesses contêineres.
  2. Imagens do Docker: Uma imagem é um arquivo inerte, imutável, que é essencialmente um instantâneo de um contêiner. Estes são seus contêineres comprometidos reais (aqueles que têm o processo em execução, dados armazenados, portas expostas a serem usadas). As imagens do Docker são essencialmente as instâncias armazenadas que você pode (realmente se movimentar).
  3. Dockerfile: É um arquivo baseado em YAML (quase) do qual o Docker cria uma imagem. Pode ser considerado como um script automatizado que possui todas as etapas que você deseja executar.

Você pode ser um entusiasta da Ciência de Dados que pode compartilhar seu código sem documentar qualquer coisa, o Dockerfile (mais sobre isso depois) é auto-documentado. Tudo o que você precisa fazer é criar uma imagem do Docker, carregá-la no DockerHub e compartilhá-la com o mundo!

Um bom recurso para saber mais sobre a tecnologia Docker e Containerization como um todo é ler este blog .

Neste post, abordaremos problemas muito restritos de começar com imagens do Docker pré-construídas e o pacote Ambiente .

Instalação do Docker

Todos os exemplos aqui são genéricos, exceto pela instalação do Docker . Os documentos oficiais de instalação do Docker para Windows e Mac são bastante diretos. Você pode começar a instalação do Docker usando esta postagem no blog DigitalOcean .

( Dica: Para qualquer instalação relacionada à distribuição Linux, os artigos da DigitalOcean são o verdadeiro negócio! Pesquise sempre por eles. )

Docker para gratificação instantânea

Obtendo a ferramenta certa para fazer as coisas é difícil e instalá-lo em seu sistema é um trabalho difícil, às vezes.

Vamos dar um exemplo da instalação de cryptography do Python em seu sistema Windows, a menos que você tenha o compilador C ++ autorizado pela Microsoft que o pacote não pip install . Depois de tentativas ardorosas e cansativas, você pode fazer as coisas funcionarem. No Ubuntu, a instalação é apenas uma brisa.

Leia minhas experiências na compilação do TensorFlow Serving, que lhe daria uma ideia justa de que configurar a plataforma para fazer as coisas, especialmente coisas obscuras, leva tempo.

O Docker resolve isso, o DockerHub tem uma série de imagens carregadas por indivíduos e equipes de tecnologia. Direito de imagens Hello World para imagens LISP .

O que você precisa fazer? Apenas docker pull <username>/<image-name> . Ele iria baixar a imagem para você. Experimente o seguinte:

 user@user:~$ docker pull hello-world 
 Using default tag: latest 
latest: Pulling from library/hello-world
78445dd45222: Pull complete
Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status: Downloaded newer image for hello-world:latest

Para executar o comando de execução de imagem do docker, conforme abaixo:

docker run hello-world

Deve dar-lhe saída:

 Hello from Docker! 
 This message shows that your installation appears to be working correctly. 
 To generate this message, Docker took the following steps: 
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.
 To try something more ambitious, you can run an Ubuntu container with: 
 $ docker run -it ubuntu bash 
 Share images, automate workflows, and more with a free Docker ID: https://cloud.docker.com/ 
 For more examples and ideas, visit: https://docs.docker.com/engine/userguide/ 

Geralmente, os arquivos docker que você usaria para fins de Data Science seriam muito complexos com uma variedade de componentes para serem tratados: portas, volumes e muitas outras coisas.

Vamos ver como executar um notebook Jupyter Anaconda completo que tenha todos os componentes pré-instalados. (Uma versão mais fácil da instalação do conda ).

 user@user:~$ docker pull continuumio/anaconda3 
 Using default tag: latest 
latest: Pulling from continuumio/anaconda3
8ad8b3f87b37: Pull complete
26e5bbd29116: Pull complete
26a23cde1ff7: Pull complete
0947a413f98b: Pull complete
Digest: sha256:d04148529d340097c08677061e7d08f42e13a51dbdbf7488d92af0a65fd82973
Status: Downloaded newer image for continuumio/anaconda3:latest

Para efetuar login no contêiner docker, podemos executar o comando abaixo: – docker run -i -t continuumio/anaconda3 /bin/bash

Para executar o notebook Jupyter em um modo no-browser , execute o comando abaixo: – docker run -i -t -p 8888:8888 continuumio/anaconda3 /bin/bash -c "/opt/conda/bin/conda install jupyter -y --quiet && mkdir /opt/notebooks && /opt/conda/bin/jupyter notebook --notebook-dir=/opt/notebooks --ip='*' --port=8888 --no-browser"

Aqui, vamos discutir o que o segundo comando está fazendo:

  • -i está executando a imagem interativamente.
  • -t aloca um pseudo-TTY.
  • -p é conectar / publicar as portas do contêiner para hospedar. Aqui localhost: 8888 para 8888 do container.

Baixando o jupyter e iniciando os notebooks no modo --no-browser .

Mais alguns que você deve saber são:

  • -d é executar o contêiner em segundo plano, sem fechar acidentalmente.
  • -v é ligar um volume ao contêiner, útil quando você deseja que seus blocos de anotações e / ou dados sejam refletidos no contêiner de seu sistema local.

Vá para o navegador e execute http: // localhost: 8888 para começar a executar suas experiências. Muito bacana, se você quiser começar facilmente usando um contêiner docker ready-made.

Mas tudo isso não resolve o nosso problema principal: Gerenciando Ambientes .

Gerencie ambientes e deixe que outros usem isso facilmente!

Para meu trabalho diário, eu crio ambientes virtuais para cada projeto usando a distribuição Anaconda . Ele fornece um meio muito fácil de compartilhar código junto com o arquivo environment.yml que pode ser exportado e usado para instalar o ambiente inteiro.

Há uma boa portabilidade aqui, lembre-se, mas ainda pode cruzar instalações do sistema operacional (SO). É aí que o docker brilha e com uma grande quantidade de componentes do ecossistema, como docker-compose e docker-machine , é mais fácil do que nunca iniciar e executar com um aplicativo Data Science tangível.

Para começar, vamos criar um Dockerfile . Como explicado acima, o Dockerfile se encarregaria de configurar a imagem para você que inclui o download das imagens básicas, a configuração do nome-do-mantenedor, a instalação dos programas ubuntu / debian necessários, a instalação de dependências de idiomas e muito mais.

Criaremos uma imagem do Docker baseada em python3.5 que conteria data pastas e notebooks com portas 8888 expostos para conexão com jupyter notebooks .

( Nota: Se algum dos módulos python não puder ser instalado via pip, seria seguro escrever comandos RUN para executá-los com segurança ).

Crie uma pasta com a estrutura da árvore como abaixo:

 . 
??? dados
Read ??? readme.md
Dock?? Dockerfile
Notebook?? notebook
Read ??? readme.md
RE?? README.md
Requirements?? requirements.txt

Nós temos o arquivo requirements.txt como abaixo: ( Nota: Do pip freeze > requirements.txt para gerar um para o seu ambiente conda )

Vamos começar com componentes menores para o nosso Dockerfile .

imagem de base:

Para simplificar, a imagem base que usaremos é a imagem python:3.5.3-onbuild . Tudo o que precisamos é de um arquivo requirements.txt que tenha todos os módulos python a serem instalados.

Ele faz o seguinte:

  • Instalar o python 3.5.3
  • Puxe sua fonte e coloque-a em um lugar visível e movimentável.
  • Instale seu arquivo requirements.txt.

( Nota: Isso criaria um contêiner do Debian, não um do Ubuntu )

 FROM python:3.5.3-onbuild 

Atualizando as origens do repositório

  • Criando pastas para data e notebooks
 RUN mkdir /data RUN mkdir /notebooks 

Adicionando uma pasta de log temporária em /tmp , usando:

 RUN mkdir /tmp/tflearn_logs 

Faça essas três pastas como VOLUMES para que também possam ser acessadas pela máquina host.

  • A principal razão que temos VOLUMES é que os data e os notebooks podem ser compartilhados separadamente, não através das imagens que criamos (as práticas recomendadas do Docker afirmam que não é bom compartilhar dados com Imagens, isso poderia ser feito, mas evitado).
 VOLUME ["/data", "/notebooks", '/tmp/tflearn_logs'] 

Às vezes, podemos ter instalações como curl ou cron que não estejam exatamente em nossa imagem de base. Vamos RUN as instalações conforme abaixo:

 RUN apt-get install cron -yqq  curl 

Nós vamos expor a porta:

 # jupyter 
EXPOSE 8888

Nós vamos ter que fazer um arranjo de alguma forma para iniciar o notebook Jupyter enquanto nós executamos nossa imagem. Para isso, usaremos o CMD para executar nossos comandos:

 CMD jupyter notebook --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token='demo' 

Finalmente, temos nosso Dockerfile como abaixo:

Precisamos construir a imagem do docker executando o seguinte comando:

 (sudo) docker build -t <image-name> . 

Uma simples inspeção (abaixo), forneceria as estatísticas da imagem gerada:

 user@user:~/docker-demo$ sudo docker images 
 REPOSITORY TAG IMAGE ID CREATED SIZE 
demoimage latest 9d556dd63886 9 minutes ago 1.37 GB

Agora, o teste real é enviado, precisamos testá-lo executando a imagem e verificando se nossos volumes funcionam ou não!

Siga os comandos abaixo:

 (sudo) docker run -d -v ~/docker-demo/notebooks:/notebooks -v ~/docker-demo/data:/data  -v ~/docker-demo/logs:/tmp/tflearn_logs -p 8888:8888 -i demoimage 

Se você fizer um sudo docker ps , você obterá a seguinte saída:

 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 
fadf5e0646d5 demoimage "/bin/sh -c 'tenso..." 9 seconds ago
Up 8 seconds 0.0.0.0:6006->6006/tcp, 0.0.0.0:8888->8888/tcp clever_payne

Então, estamos todos prontos para testar a imagem do docker:

As pastas do contêiner e do host seriam sincronizadas e persistidas, não há necessidade de se preocupar em perder o notebook, os dados e os registros.

O último passo seria salvar esta imagem no DockerHub como uma imagem pública ou em um repositório privado para usá-la posteriormente.

 # Login to DockerHub (_Note: You need to create your DockerHub account first_) 
(sudo) docker login

Uma vez que o login for bem-sucedido, precisamos marcar a imagem e, em seguida, empurrar a imagem:

 (sudo) docker tag <image-name> <login-id>/<image-name> 
(sudo) docker push <login-id>/<image-name>

por exemplo

  • (sudo) docker tag demoimage pratos / demoimage
  • (sudo) docker push pratos / demoimage

Então aqui está, sua própria imagem do docker . Meu colega ficaria feliz em ver isso, como ele, mesmo que você pudesse fazer mais com imagens docker . Tente isso.

Nós veríamos mais algumas coisas que o Docker oferece no próximo post. Para todos os povos de DevOps fornecem o feedback a este borne e compartilham-no com todos nós.

Fontes:

  1. Para um entendimento mais profundo e simples sobre como escrever um Dockerfile

2. Documentação do Docker

Sinta-se à vontade para compartilhar!