10 ideias de projetos do Docker: Do iniciante ao avançado

Projetos do Docker de nível intermediário

Os projetos a seguir são para aqueles que têm um sólido conhecimento dos conceitos básicos do Docker. Nelas, você aprenderá conceitos mais complexos, como compilações em vários estágios e técnicas de otimização.

Projeto 4: Criação em vários estágios para um aplicativo Node.js

As compilações em vários estágios ajudam a reduzir o tamanho das imagens do Docker, separando os ambientes de compilação e de tempo de execução. Neste projeto, você colocará em contêiner um aplicativo Node.js usando compilações em vários estágios.

Nível de dificuldade: Intermediário

Tecnologias utilizadas: Docker, Node.js, Nginx

Instruções passo a passo

• Crie um aplicativo Node.js simples: Escreva um servidor Node.js básico que retorne uma mensagem simples. Aqui está um exemplo:

const express = require('express');
const app = express();
 
app.get('/', (req, res) => res.send('Hello from Node.js'));
 
app.listen(3000, () => console.log('Server running on port 3000'));

• Escreva o Dockerfile com compilação em vários estágios: O primeiro estágio cria o aplicativo, e o segundo estágio executa o aplicativo com uma imagem de base mais clara.

# Stage 1: Build
FROM node:14 as build-stage
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
# Add the following line if there's a build step for the app
# RUN npm run build

# Stage 2: Run
FROM node:14-slim
WORKDIR /app
COPY --from=build-stage /app .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "server.js"]

• Crie a imagem:

docker build -t node-multi-stage .

• Execute o contêiner:

docker run -p 3000:3000 node-multi-stage

Projeto 5: Dockerização de um modelo de aprendizado de máquina com o TensorFlow

Este projeto envolverá a conteinerização de um modelo de aprendizado de máquina usando o TensorFlow. O objetivo é criar um ambiente portátil no qual você possa executar modelos do TensorFlow em vários sistemas sem se preocupar com a configuração subjacente.

Nível de dificuldade: Intermediário

Tecnologias utilizadas: Docker, TensorFlow, Python

Instruções passo a passo

• Instale o TensorFlow em um script Python: Crie um script Python model.py que carregue e execute um modelo TensorFlow pré-treinado:

import tensorflow as tf
model = tf.keras.applications.MobileNetV2(weights='imagenet')
print("Model loaded successfully")

• Escreva o Dockerfile: Defina o ambiente para o TensorFlow dentro do Docker:

FROM tensorflow/tensorflow:latest
WORKDIR /app
COPY . .
CMD ["python", "model.py"]

• Crie a imagem:

docker build -t tensorflow-model .

• Execute o contêiner:

docker run tensorflow-model

Projeto 6: Criando um ambiente de ciência de dados com o Jupyter e o Docker

Este projeto se concentra na criação de um ambiente de ciência de dados reproduzível usando o Docker e os notebooks Jupyter. O ambiente incluirá bibliotecas Python populares, como pandas, NumPy e scikit-learn.

Nível de dificuldade: Intermediário

Tecnologias utilizadas: Docker, Jupyter, Python, scikit-learn

Instruções passo a passo

• Crie o arquivo docker-compose.yml: Defina o serviço do Jupyter Notebook e as bibliotecas necessárias. Aqui está um exemplo:

version: '3'
services:
  jupyter:
    	image: jupyter/scipy-notebook
    	ports:
    	- "8888:8888"
    	volumes:
    	- ./notebooks:/home/joelwembo/work

• Inicie o Jupyter Notebook: Use o Docker Compose para iniciar o Jupyter Notebook.

docker-compose up

• Acesse o Jupyter Notebook: Abra seu navegador e acesse http://localhost:8888.

Projetos do Docker de nível avançado

Esses projetos de nível avançado se concentrarão em aplicativos do mundo real e conceitos avançados do Docker, como pipelines de aprendizagem profunda e pipelines de dados automatizados.

Projeto 7: Reduzindo o tamanho de uma imagem do Docker para um aplicativo Python

Neste projeto, você otimizará uma imagem do Docker para um aplicativo Python usando imagens básicas mínimas, como o Alpine Linux, e implementando compilações em vários estágios para manter o tamanho da imagem o menor possível.

Nível de dificuldade: Avançado

Tecnologias utilizadas: Docker, Python, Alpine Linux

Instruções passo a passo

• Escreva o script Python: Crie um script que analise dados usando o pandas. Aqui está um exemplo de script:

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())

• Otimize o Dockerfile: Use compilações em vários estágios e o Alpine Linux para criar uma imagem leve.

# Stage 1: Build stage
FROM python:3.9-alpine as build-stage
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY script.py .

# Stage 2: Run stage
FROM python:3.9-alpine
WORKDIR /app
COPY --from=build-stage /app/script.py .
CMD ["python", "script.py"]

• Crie a imagem:

docker build -t optimized-python-app .

Projeto 8: Dockerização de um pipeline de aprendizagem profunda com o PyTorch

Este projeto envolve a conteinerização de um pipeline de aprendizagem profunda usando o PyTorch. O foco é otimizar o Dockerfile para desempenho e tamanho, facilitando a execução de modelos de aprendizagem profunda em diferentes ambientes.

Nível de dificuldade: Avançado

Tecnologias utilizadas: Docker, PyTorch, Python

Instruções passo a passo

• Instale o PyTorch em um script Python: Crie um script que carregue um modelo PyTorch pré-treinado e realize a inferência. Aqui está um exemplo:

import torch
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
print("Model loaded successfully")

• Escreva o Dockerfile: Defina o ambiente para o PyTorch:

FROM pytorch/pytorch:1.9.0-cuda11.1-cudnn8-runtime
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.py .
CMD ["python", "model.py"]

• Crie a imagem:

docker build -t pytorch-model .

• Execute o contêiner:

docker run pytorch-model 

Projeto 9: Automatizando pipelines de dados com o Apache Airflow e o Docker

Neste projeto, você configurará e colocará em contêiner um ambiente do Apache Airflow para automatizar pipelines de dados. O Apache Airflow é uma ferramenta popular para orquestrar fluxos de trabalho complexos amplamente usados na engenharia de dados.

Nível de dificuldade: Avançado

Tecnologias utilizadas: Docker, Apache Airflow, Python, PostgreSQL

Instruções passo a passo

• Crie o arquivo docker-compose.yml: Defina os serviços do Airflow e o banco de dados PostgreSQL:

version: '3'
services:
  postgres:
    image: postgres:latest
    environment:
      POSTGRES_USER: airflow
      POSTGRES_PASSWORD: airflow
      POSTGRES_DB: airflow
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  webserver:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
    ports:
      - "8080:8080"
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["webserver"]

  scheduler:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
      - webserver
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["scheduler"]

volumes:
  postgres_data:

• Inicie o ambiente Airflow: Use o Docker Compose para criar o ambiente do Airflow:

docker-compose up

• Acesse a interface do usuário do Airflow: Abra seu navegador e acesse http://localhost:8080.

Projeto 10: Implementação de uma API de ciência de dados com FastAPI e Docker

Crie e implemente uma API de ciência de dados usando FastAPI. Você colocará a API em contêineres usando o Docker e se concentrará em otimizá-la para ambientes de produção.

Nível de dificuldade: Avançado

Tecnologias utilizadas: Docker, FastAPI, Python, scikit-learn

Instruções passo a passo

• Escreva o aplicativo FastAPI: Crie uma API simples que use um modelo de aprendizado de máquina para previsões. Aqui está um exemplo:

from fastapi import FastAPI
import pickle
 
app = FastAPI()
with open("model.pkl", "rb") as f:
   model = pickle.load(f)
 
@app.post("/predict/")
def predict(data: list):
   return {"prediction": model.predict(data)}

• Escreva o Dockerfile: Crie um Dockerfile que defina o ambiente para o FastAPI:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

• Crie a imagem:

docker build -t fastapi-app .

• Execute o contêiner:

docker run -p 8000:8000 fastapi-app

Dicas para trabalhar em projetos do Docker

Enquanto você trabalha nesses projetos, tenha em mente as dicas a seguir:

• Comece com pouco: Comece com projetos ligeiramente desafiadores e depois passe para tarefas mais complexas. É fundamental desenvolver a confiança em tarefas mais simples.
• Documente seu progresso: Mantenha um registro detalhado de seus projetos para acompanhar seu aprendizado e usá-lo como referência para empreendimentos futuros.
• Participe das comunidades do Docker: Participe de fóruns on-line e encontros locais para compartilhar suas experiências, fazer perguntas e aprender com outras pessoas.
• Experimente e personalize: Não tenha medo de ajustar os projetos, tentar abordagens diferentes e explorar novos recursos do Docker.
• Continue aprendendo: Continue a expandir seus conhecimentos sobre o Docker explorando tópicos e ferramentas avançados, como Kubernetes, Docker Swarm ou arquitetura de microsserviços.

Conclusão

Dominar o Docker envolve mais do que apenas aprender comandos e configurações. Trata-se de entender como o Docker se encaixa no desenvolvimento de aplicativos modernos, nos fluxos de trabalho de ciência de dados e no gerenciamento de infraestrutura.

Os projetos que compartilhei neste guia forneceram algumas ideias para você desenvolver as habilidades básicas e a experiência prática necessárias para se destacar em cenários do mundo real.

Nesse momento, sugiro que você solidifique seu conhecimento seguindo esses cursos:

• Docker intermediário
• Introdução ao Kubernetes