Como aprender o Docker do zero: Um guia para profissionais de dados

Etapa 3: Execute seu primeiro contêiner

Agora que o Docker está instalado, é hora de executar seu primeiro contêiner. Começaremos com a imagem simple hello-world, perfeita para iniciantes.

1. Abra o terminal (ou o prompt de comando no Windows) e execute o seguinte comando:

sudo docker run hello-world

Esse comando diz ao Docker para procurar a imagem hello-world localmente. Se não a encontrar, o Docker extrairá a imagem do Docker Hub e a executará.

Se o Docker estiver instalado corretamente, você verá uma mensagem que diz: "Hello from Docker!" (Olá do Docker!), juntamente com detalhes sobre como o processo do Docker funciona. Essa saída confirma que o Docker extraiu a imagem com sucesso, criou um novo contêiner e executou o código dentro dele.

Etapa 4: Crie sua primeira imagem do Docker

Nesta etapa, você criará uma imagem personalizada do Docker para um projeto simples de ciência de dados. Essa imagem incluirá Python e bibliotecas comuns de ciência de dados, como pandas, NumPy e scikit-learn.

1. Crie um novo diretório:

• • Comece criando um novo diretório para o seu projeto e navegando até ele:

mkdir my-data-science-app
cd my-data-science-app

2. Crie um Dockerfile:

Dentro desse diretório, crie um arquivo chamado Dockerfile (sem nenhuma extensão de arquivo):

# Use an official Python runtime as a parent image
FROM python:3.8-slim
 
# Set the working directory in the container
WORKDIR /app
 
# Copy the current directory contents into the container at /app
COPY . /app
 
# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
 
# Make port 8888 available to the world outside this container
EXPOSE 8888
 
# Run a Jupyter notebook server when the container launches
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

O Dockerfile faz o seguinte:

• FROM python:3.8-slim: Isso define a imagem base para o Python 3.8 em sua variante slim, uma versão mínima do Python, ideal para um ambiente leve de ciência de dados.
• WORKDIR /app: Isso define o diretório de trabalho dentro do contêiner como /app. Todos os comandos subsequentes serão executados nesse diretório.
• COPY . /app: Isso copia todos os arquivos do seu diretório atual na máquina host e os coloca no diretório /app no contêiner. Isso normalmente inclui seus scripts de ciência de dados e arquivos de configuração.
• RUN pip install --no-cache-dir -r requirements.txt: Isso instala as bibliotecas Python listadas em requirements.txt. As bibliotecas comuns para ciência de dados incluem pandas, NumPy e scikit-learn.
• EXPOSE 8888: Isso torna a porta 8888 disponível para o computador host, a porta padrão dos notebooks Jupyter.
• CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]: Esse comando inicia um servidor de notebook Jupyter quando o contêiner é iniciado, tornando-o acessível a partir do seu navegador da Web.

3. Crie um arquivo requirements.txt:

No mesmo diretório, crie um arquivo requirements.txt para listar os pacotes Python de que seu aplicativo precisa:

pandas
numpy
scikit-learn
matplotlib

Esse arquivo lista as bibliotecas Python que serão instaladas dentro do seu contêiner do Docker.

4. Crie a imagem do Docker:

• Com o Dockerfile e o site requirements.txt prontos, crie sua imagem do Docker usando o seguinte comando:

sudo docker build -t my-data-science-app .

O comando acima faz o seguinte:

• docker build: Inicia o processo de criação de uma imagem do Docker.
• -t my-data-science-app: A opção -t marca a imagem como "my-data-science-app".
• .: O ponto no final especifica o contexto de compilação, que é o diretório atual. O Docker usará os arquivos desse diretório para criar a imagem.

5. Execute a imagem do Docker:

Quando o processo de compilação estiver concluído, você poderá executar sua nova imagem do Docker como um contêiner:

sudo docker run -p 8888:8888 my-data-science-app

Vamos detalhar o comando:

• docker run: Executa um contêiner com base na imagem especificada.
• -p 8888:8888: A opção -p mapeia a porta 8888 no seu computador local para a porta 8888 dentro do contêiner, permitindo que você acesse o servidor do Jupyter Notebook navegando para localhost:8888 no seu navegador da Web.
• my-data-science-app: Isso especifica a imagem a ser executada.

Etapa 5: Use o Docker Compose

O Docker Compose é uma ferramenta essencial para gerenciar aplicativos com vários contêineres. Em um projeto de ciência de dados, você pode precisar de contêineres separados para diferentes componentes, como um notebook Jupyter, um banco de dados para armazenar dados e uma ferramenta de visualização de dados.

O Docker Compose permite que você defina esses serviços em um único arquivo YAML, facilitando a ativação de todo o seu ambiente de ciência de dados com um único comando.

1. Crie um arquivo docker-compose.yml:

• No diretório do seu projeto, crie um arquivo chamado docker-compose.yml e escreva as seguintes linhas no arquivo:

version: '3.8'
services:
  jupyter:
        image: jupyter/scipy-notebook:latest
        volumes:
        - ./notebooks:/home/joelwembo/work
        ports:
        - "8888:8888"
        environment:
        - JUPYTER_ENABLE_LAB=yes
 
  postgres:
        image: postgres:13-alpine
        environment:
        POSTGRES_USER: myuser
        POSTGRES_PASSWORD: mypassword
        POSTGRES_DB: mydatabase
        volumes:
        - postgres_data:/var/lib/postgresql/data
        ports:
        - "5432:5432"
 
  redis:
        image: redis:alpine
        ports:
        - "6379:6379"
 
volumes:
  postgres_data:
 

Vamos detalhar o que o arquivo Docker Compose faz:

• version: '3.8': Especifica a versão do formato de arquivo do Docker Compose. A versão 3.8 é uma versão comumente usada que oferece suporte a muitos recursos.
• services:: A seção de serviços define os diferentes contêineres (serviços) que compõem o seu aplicativo.
• jupyter:: Esse serviço representa um ambiente de notebook Jupyter essencial para a análise interativa de dados.
• image: jupyter/scipy-notebook:latest: Isso especifica a imagem do Docker a ser usada para o notebook Jupyter, que inclui bibliotecas populares de ciência de dados, como NumPy, pandas e matplotlib.
• volumes: - ./notebooks:/home/joelwembo/work: Isso monta o diretório de notebooks no computador host em /home/joelwembo/work dentro do contêiner, permitindo que você mantenha e compartilhe seus notebooks. Observação: Esse é o meu caminho pessoal, e o seu deve ser diferente.
• ports: - "8888:8888": Isso mapeia a porta 8888 no seu computador host para a porta 8888 no contêiner, que é a porta padrão para os notebooks Jupyter.
• environment: - JUPYTER_ENABLE_LAB=yes: Isso habilita o JupyterLab, uma interface mais avançada para você trabalhar com notebooks Jupyter.
• postgres:: Esse serviço executa um banco de dados PostgreSQL, que é frequentemente usado para armazenar e gerenciar grandes conjuntos de dados em projetos de ciência de dados.
• image: postgres:13-alpine: Isso especifica a imagem do Docker para o PostgreSQL versão 13, com base na distribuição leve do Alpine Linux.
• environment:: Essas variáveis de ambiente configuram o banco de dados com um usuário, uma senha e um nome de banco de dados.
• volumes: - postgres_data:/var/lib/postgresql/data: Isso monta um volume do Docker para manter os dados do banco de dados fora do contêiner, para que os dados não sejam perdidos quando o contêiner for interrompido.
• ports: - "5432:5432": Isso mapeia a porta 5432 no seu computador host para a porta 5432 no contêiner, a porta padrão do PostgreSQL.
• redis:: Esse serviço executa um servidor Redis, que pode ser usado como um cache ou armazenamento rápido de dados na memória.
• image: redis:alpine: Isso especifica a imagem do Redis usando a variante leve do Alpine.
• ports: - "6379:6379": Isso mapeia a porta 6379 no seu computador host para a porta 6379 no contêiner, a porta padrão do Redis.
• volumes:: Esta seção define volumes nomeados que podem ser compartilhados entre serviços ou persistir dados entre reinicializações de contêineres.
• postgres_data:: Isso cria um volume nomeado para persistir os dados do PostgreSQL.

Para iniciar seu aplicativo de vários contêineres, basta executar o seguinte:

sudo docker compose up

Esse comando cria as imagens (se necessário) e inicia os contêineres definidos no seu arquivo docker-compose.yml. Ele abre o aplicativo da Web e o serviço Redis, permitindo que eles se comuniquem entre si conforme definido.

Agora você implantou seu primeiro aplicativo Docker! Você não acha isso ótimo? Agora, vamos elaborar um plano para seu aprendizado contínuo.

Um exemplo de plano de aprendizado para o Docker

Aqui está um plano semanal que você pode seguir. Sinta-se à vontade para adaptá-lo às suas necessidades específicas. 

Se você precisa de um caminho mais definido, o treinamento de habilidades em Containerization and Virtualization with Docker and Kubernetes é perfeito para você. Ele contém quatro cursos essenciais.

Semana 1: Familiarize-se com os conceitos básicos do Docker

• Objetivo: Compreender os principais conceitos e comandos básicos do Docker.
• Tarefas:
• Instale o Docker e configure o Docker Desktop.
• Aprenda os comandos do Docker: docker run, docker ps, docker stop, docker rm, etc.
• Execute contêineres simples para ferramentas de exploração de dados, como Ubuntu ou Alpine, e experimente comandos básicos.
• Explore imagens oficiais do Docker e execute contêineres para ferramentas básicas de visualização (por exemplo, um contêiner simples do matplotlib).
• Recursos: Curso de Conceitos de Containerização e Virtualização, curso de Introdução ao Docker.

Semana 2: Criar e executar imagens do Docker para ferramentas de dados

• Objetivo: Aprenda a criar e gerenciar imagens personalizadas do Docker.
• Tarefas:
• Escreva um Dockerfile para um ambiente básico de análise de dados (por exemplo, Python com Pandas e NumPy).
• Crie a imagem do Docker usando o docker build.
• Execute contêineres a partir de sua imagem personalizada e teste ferramentas de dados como o Jupyter Notebook.
• Crie Dockerfiles para TensorFlow e PostgreSQL, garantindo a configuração e a vinculação adequadas.
• Recursos: Curso de introdução ao Docker.

Semana 3: Explore o Docker Compose

• Objetivo: Compreender e utilizar o Docker Compose para configurações de vários contêineres.
• Tarefas:
• Instale o Docker Compose e aprenda seus conceitos básicos.
• Escreva arquivos docker-compose.yml para definir aplicativos com vários contêineres.
• Pratique com exemplos como a configuração de um aplicativo da Web com um banco de dados de back-end (por exemplo, um aplicativo Flask com PostgreSQL).
• Faça experiências com diferentes configurações e dependências de serviço.
• Recursos: Curso de Docker intermediário.

Semana 4: Mergulhe fundo na rede e nos volumes do Docker

• Objetivo: Domine os recursos de rede e armazenamento do Docker.
• Tarefas:
• Saiba mais sobre as redes do Docker e como criá-las (ponte, host, sobreposição).
• Pratique a criação de redes personalizadas e a conexão de contêineres a elas.
• Explore os volumes do Docker para armazenamento persistente e pratique a criação e o gerenciamento deles.
• Implemente uma configuração em que os contêineres se comuniquem por meio de uma rede personalizada e usem volumes para persistência de dados.
• Recursos: Curso de Docker intermediário.

Semana 5: Implantar e gerenciar contêineres do Docker na produção

• Objetivo: Compreender a implantação e o gerenciamento de contêineres na produção.
• Tarefas:
• Aprenda as práticas recomendadas para a implantação de contêineres do Docker (por exemplo, usando o Docker Hub ou um registro privado).
• Explore a orquestração de contêineres com o Docker Swarm: criação e gerenciamento de serviços.
• Entenda como dimensionar contêineres e gerenciar logs.
• Experimente a implantação de um aplicativo em contêiner em um ambiente de preparação ou produção.
• Recursos: Curso de Docker intermediário.

Semana 6: Introdução ao Kubernetes para orquestração de contêineres

• Objetivo: Familiarize-se com o Kubernetes para dimensionar e gerenciar aplicativos em contêineres.
• Tarefas:
• Instale e configure um ambiente Kubernetes local (por exemplo, Minikube ou Kind).
• Aprenda os conceitos básicos do Kubernetes: pods, serviços, implantações e namespaces.
• Implante um aplicativo simples em contêiner no Kubernetes.
• Explore o dimensionamento e o gerenciamento de aplicativos com o Kubernetes, concentrando-se no manuseio de uma ferramenta de dados em contêineres como o Jupyter.
• Recursos: Curso de introdução ao Kubernetes.

Dicas e maneiras de aprender a usar o Docker

Por fim, aqui estão algumas dicas e práticas recomendadas para ajudar você a acelerar seu caminho de aprendizado do Docker.

Pratique regularmente

A chave para você dominar o Docker é a prática consistente e prática. Comece trabalhando em projetos pessoais, como a conteinerização de um site simples ou a configuração de um ambiente de desenvolvimento local. 

À medida que você se sentir mais confortável, desafie-se com tarefas mais complexas, como a criação de um aplicativo com vários contêineres ou a implantação de um servidor da Web. 

A experimentação regular com diferentes casos de uso, como a criação de imagens personalizadas do Docker ou a configuração deum pipeline de CI/CD,aprofundará sua compreensão e ajudará a solidificar os principais conceitos. Além disso, participar de desafios ou exercícios on-line do Docker é uma ótima maneira de testar e aprimorar suas habilidades de forma estruturada e orientada por metas.

Use recursos on-line

Os recursos on-line são inestimáveis para você aprender o Docker. A documentação oficial do Docker é um excelente ponto de partida, pois oferece informações confiáveis e atualizadas. 

Além disso, há muitos cursos abrangentes disponíveis em plataformas como o DataCamp, que podem ajudar a orientar você no processo de aprendizagem. 

Para aqueles que preferem o aprendizado visual, os tutoriais do YouTube do canal oficial do Docker e de outros educadores fornecem conteúdo útil e acessível para reforçar sua compreensão.

Participe da comunidade Docker

O envolvimento com a comunidade do Docker é outra maneira poderosa de avançar seu aprendizado. Participe de fóruns como o Docker Community Forums e o Reddit para trocar ideias, fazer perguntas e compartilhar experiências com outros alunos e profissionais. 

Participar de encontros, webinars ou conferências do Docker também é uma ótima maneira de se manter atualizado com as tendências do setor e ampliar sua rede de contatos.

Trabalhar em projetos de código aberto

Contribuir com projetos de código aberto que utilizam o Docker pode ser uma maneira fantástica de ganhar experiência prática e real. 

Sites como o GitHub oferecem oportunidades de colaboração em projetos relacionados ao Docker, permitindo que você aprenda com outras pessoas e aplique suas habilidades em diversos contextos. A colaboração inerente ao trabalho de código aberto ajuda a expor você a diferentes abordagens e soluções, promovendo uma compreensão mais profunda dos recursos do Docker.

Mantenha-se atualizado

Por fim, manter-se atualizado com os últimos desenvolvimentos do Docker é essencial para manter a proficiência. Fique de olho no blog oficial do Docker e nas notas de versão para obter atualizações sobre novos recursos ou alterações. Participar de discussões da comunidade em fóruns e mídias sociais também informará você sobre tendências emergentes e práticas recomendadas, ajudando-o a aperfeiçoar continuamente suas habilidades no Docker.

Com a prática regular, o envolvimento ativo da comunidade e o aprendizado contínuo, você criará uma base sólida no Docker e permanecerá equipado para lidar com os desenvolvimentos mais recentes na área.

Conclusão

O Docker revolucionou a implantação de aplicativos e o gerenciamento de dados ao empacotar aplicativos e suas dependências em contêineres isolados. Isso resolve desafios comuns, como inconsistências de ambiente, e garante que os fluxos de trabalho permaneçam consistentes, dimensionáveis e eficientes para os profissionais de dados.

Este guia fornece as etapas fundamentais para você dominar o Docker, desde os principais conceitos até as implementações práticas. Para aprofundar ainda mais seu conhecimento, considere explorar recursos adicionais, como os cursos Introdução ao Docker e Docker Intermediário no DataCamp. À medida que você avança, expandir suas habilidades com ferramentas de orquestração como o Kubernetes é igualmente importante - confira o curso Introdução ao Kubernetes para começar.

Praticando regularmente, usando os recursos disponíveis e mantendo-se engajado com a comunidade, você poderá desbloquear todo o potencial do Docker para gerenciar ambientes de dados complexos.