🔧 Setup Environnement

Guide d’installation progressif pour le bootcamp Data Engineering

Note📌 Installation Progressive

Installez uniquement les outils du niveau que vous commencez. Vous ajouterez les autres au fur et à mesure de votre progression.

📋 Prérequis Système

Composant Minimum Recommandé
OS macOS 12+, Ubuntu 20.04+, Windows 10+ (WSL2) macOS 13+, Ubuntu 22.04+
RAM 8 Go 16 Go
CPU 4 cœurs 8 cœurs
Disque 50 Go libres 100 Go SSD
AvertissementWindows Users

Utilisez WSL2 (Windows Subsystem for Linux) pour une meilleure compatibilité. Guide d’installation WSL2

🟦 Niveau 1 : Débutant

Outils requis : Git, Python, Jupyter, VS Code, PostgreSQL, MongoDB

1.1 Git

brew install git
sudo apt update
sudo apt install git
sudo apt update
sudo apt install git

Configuration initiale

git config --global user.name "Votre Nom"
git config --global user.email "votre.email@example.com"
git config --global init.defaultBranch main

# Vérifier
git --version  # ✓ 2.30+

1.2 Python

brew install python@3.11
sudo apt update
sudo apt install python3.11 python3.11-venv python3-pip
sudo apt update
sudo apt install python3.11 python3.11-venv python3-pip

Environnement virtuel

# Créer le venv
python3 -m venv ~/bootcamp-env

# Activer (Linux/macOS)
source ~/bootcamp-env/bin/activate

# Activer (Windows PowerShell)
.\bootcamp-env\Scripts\Activate.ps1

# Mettre à jour pip
pip install --upgrade pip

# Packages Niveau Débutant
pip install pandas numpy matplotlib seaborn requests
# Vérifier
python3 --version  # ✓ 3.10+

1.3 Jupyter Notebook

# Activer votre venv
source ~/bootcamp-env/bin/activate

# Installer Jupyter
pip install jupyter jupyterlab notebook ipykernel

# Enregistrer le kernel
python -m ipykernel install --user --name=bootcamp --display-name="Python (Bootcamp)"

Lancer Jupyter

# JupyterLab (recommandé)
jupyter lab

# Ou Notebook classique
jupyter notebook
Astuce💡 Astuce

JupyterLab s’ouvre sur http://localhost:8888. Utilisez --port=8889 si le port est occupé.

1.4 VS Code

Installation

brew install --cask visual-studio-code
sudo snap install code --classic

Télécharger depuis code.visualstudio.com

Extensions Niveau Débutant

Extension ID Description
Python ms-python.python Support Python
Jupyter ms-toolsai.jupyter Notebooks dans VS Code
Pylance ms-python.vscode-pylance IntelliSense
GitLens eamodio.gitlens Git avancé
SQL Tools mtxr.sqltools Client SQL 
# Installation en ligne de commande
code --install-extension ms-python.python
code --install-extension ms-toolsai.jupyter
code --install-extension ms-python.vscode-pylance
code --install-extension eamodio.gitlens
code --install-extension mtxr.sqltools

Configuration VS Code

Ajoutez dans Settings JSON (Ctrl+, → Open Settings JSON) :

{
  "python.defaultInterpreterPath": "~/bootcamp-env/bin/python",
  "editor.formatOnSave": true,
  "editor.fontSize": 14,
  "files.autoSave": "afterDelay"
}

1.5 PostgreSQL

# Option 1 : Installation locale
# macOS
brew install postgresql@15
brew services start postgresql@15

# Ubuntu
sudo apt install postgresql postgresql-contrib
sudo systemctl start postgresql
# Option 2 : Avec Docker (si vous l'avez déjà)
docker run -d \
  --name postgres \
  -e POSTGRES_USER=bootcamp \
  -e POSTGRES_PASSWORD=bootcamp \
  -e POSTGRES_DB=bootcamp \
  -p 5432:5432 \
  postgres:15

1.6 MongoDB

# Option 1 : MongoDB Atlas (recommandé - gratuit, cloud)
# Créer un compte sur https://www.mongodb.com/atlas
# Créer un cluster gratuit M0
# Option 2 : Docker
docker run -d \
  --name mongodb \
  -p 27017:27017 \
  mongo:7
# Client Python
pip install pymongo

✅ Checklist Niveau Débutant

echo "=== 🟦 Vérification Niveau Débutant ==="
git --version
python3 --version
jupyter --version | head -1
code --version | head -1
echo "=== ✅ Done ==="

🟩 Niveau 2 : Intermédiaire

Nouveaux outils : Docker, Kubernetes, Spark, Kafka, MinIO, dbt, Polars

NotePrérequis

Avoir installé tous les outils du Niveau Débutant.

2.1 Docker

brew install --cask docker

# Lancer Docker Desktop depuis Applications
# Installer Docker Engine
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Permissions (éviter sudo)
sudo usermod -aG docker $USER
newgrp docker

# Docker Compose
sudo apt install docker-compose-plugin

Installer Docker Desktop avec WSL2 backend.

Vérification

docker --version          # ✓ 24+
docker compose version    # ✓ 2.20+
docker run hello-world

2.2 Kubernetes (kubectl + minikube)

kubectl

brew install kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
rm kubectl

minikube

brew install minikube
minikube start --memory=4096 --cpus=2 --driver=docker
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
rm minikube-linux-amd64

minikube start --memory=4096 --cpus=2 --driver=docker

Vérification

kubectl version --client  # ✓ 1.28+
minikube status
kubectl get nodes

2.3 Java (requis pour Spark)

brew install openjdk@11

# Ajouter à ~/.zshrc
export JAVA_HOME=$(/usr/libexec/java_home -v 11)
export PATH="$JAVA_HOME/bin:$PATH"

source ~/.zshrc
sudo apt install openjdk-11-jdk

# Ajouter à ~/.bashrc
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH="$JAVA_HOME/bin:$PATH"

source ~/.bashrc
java -version  # ✓ 11+

2.4 Apache Spark

# Activer votre venv
source ~/bootcamp-env/bin/activate

# Installer PySpark
pip install pyspark==3.5.0

# Vérifier
pyspark --version  # ✓ 3.5+

Test rapide

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("test").getOrCreate()
df = spark.createDataFrame([(1, "ok")], ["id", "status"])
df.show()
spark.stop()

2.5 Apache Kafka

Créez docker-compose-kafka.yml :

version: '3.8'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    container_name: zookeeper
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - "2181:2181"

  kafka:
    image: confluentinc/cp-kafka:7.5.0
    container_name: kafka
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    container_name: kafka-ui
    depends_on:
      - kafka
    ports:
      - "8090:8080"
    environment:
      KAFKA_CLUSTERS_0_NAME: local
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:9092
docker compose -f docker-compose-kafka.yml up -d

# UI disponible sur http://localhost:8090
# Client Python
pip install kafka-python confluent-kafka

2.6 MinIO (S3 local)

docker run -d \
  --name minio \
  -p 9000:9000 \
  -p 9001:9001 \
  -e MINIO_ROOT_USER=minioadmin \
  -e MINIO_ROOT_PASSWORD=minioadmin \
  -v minio_data:/data \
  minio/minio server /data --console-address ":9001"

# Console sur http://localhost:9001

2.7 Polars & Delta Lake

source ~/bootcamp-env/bin/activate

pip install polars pyarrow delta-spark deltalake

2.8 dbt

pip install dbt-core dbt-postgres dbt-duckdb

dbt --version  # ✓ 1.7+

2.9 Extensions VS Code Niveau Intermédiaire

code --install-extension ms-azuretools.vscode-docker
code --install-extension ms-kubernetes-tools.vscode-kubernetes-tools
code --install-extension redhat.vscode-yaml

✅ Checklist Niveau Intermédiaire

echo "=== 🟩 Vérification Niveau Intermédiaire ==="
docker --version
docker compose version
kubectl version --client | head -1
java -version 2>&1 | head -1
python3 -c "import pyspark; print('PySpark:', pyspark.__version__)"
python3 -c "import polars; print('Polars:', polars.__version__)"
dbt --version | head -1
echo "=== ✅ Done ==="

🟥 Niveau 3 : Avancé

Nouveaux outils : Helm, k9s, Airflow, Scala, outils monitoring

NotePrérequis

Avoir installé tous les outils des Niveaux Débutant et Intermédiaire.

3.1 Helm

brew install helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
helm version  # ✓ 3.13+

3.2 k9s (Terminal UI pour Kubernetes)

brew install k9s
curl -sS https://webinstall.dev/k9s | bash
# Lancer k9s
k9s

3.3 Apache Airflow

# Avec pip (développement local)
pip install apache-airflow==2.8.0

# Initialiser la DB
airflow db init

# Créer un user admin
airflow users create \
  --username admin \
  --password admin \
  --firstname Admin \
  --lastname User \
  --role Admin \
  --email admin@example.com

# Lancer
airflow webserver --port 8080 &
airflow scheduler &

# UI sur http://localhost:8080

Avec Docker (recommandé pour production-like)

# Télécharger le docker-compose officiel
curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.8.0/docker-compose.yaml'

# Initialiser
mkdir -p ./dags ./logs ./plugins ./config
echo -e "AIRFLOW_UID=$(id -u)" > .env

docker compose up airflow-init
docker compose up -d

3.4 Scala (pour Spark Scala)

brew install scala@2.12 sbt
# Scala
sudo apt install scala

# sbt (build tool)
echo "deb https://repo.scala-sbt.org/scalasbt/debian all main" | sudo tee /etc/apt/sources.list.d/sbt.list
curl -sL "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x99E82A75642AC823" | sudo apt-key add
sudo apt update
sudo apt install sbt
scala -version  # ✓ 2.12.x (compatible Spark 3.5)

3.5 Outils Monitoring

Prometheus & Grafana (via Docker)

# docker-compose-monitoring.yml
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
docker compose -f docker-compose-monitoring.yml up -d

# Prometheus: http://localhost:9090
# Grafana: http://localhost:3000 (admin/admin)

3.6 ClickHouse (OLAP)

docker run -d \
  --name clickhouse \
  -p 8123:8123 \
  -p 9000:9000 \
  clickhouse/clickhouse-server
# Client Python
pip install clickhouse-connect

3.7 MLflow

pip install mlflow

# Lancer le serveur
mlflow server --host 0.0.0.0 --port 5000

# UI sur http://localhost:5000

3.8 Extensions VS Code Niveau Avancé

code --install-extension scala-lang.scala
code --install-extension scalameta.metals
code --install-extension ms-vscode-remote.remote-ssh
code --install-extension rangav.vscode-thunder-client

✅ Checklist Niveau Avancé

echo "=== 🟥 Vérification Niveau Avancé ==="
helm version | head -1
k9s version 2>/dev/null | head -1 || echo "k9s: lancer 'k9s' pour vérifier"
airflow version 2>/dev/null || echo "Airflow: vérifier avec 'airflow version'"
scala -version 2>&1 | head -1
echo "=== ✅ Done ==="

📁 Structure de Projet Recommandée

~/data-engineering-bootcamp/
├── .venv/                  # Environnement virtuel
├── data/
│   ├── raw/               # Données brutes
│   ├── processed/         # Données transformées
│   └── output/            # Résultats
├── notebooks/              # Jupyter notebooks
├── spark_jobs/             # Scripts PySpark/Scala
├── dbt_project/            # Projet dbt
├── docker/                 # Docker Compose files
├── k8s/                    # Manifests Kubernetes
├── airflow/
│   └── dags/              # DAGs Airflow
├── tests/                  # Tests unitaires
├── .gitignore
└── README.md
# Créer la structure
mkdir -p ~/data-engineering-bootcamp/{data/{raw,processed,output},notebooks,spark_jobs,dbt_project,docker,k8s,airflow/dags,tests}

cd ~/data-engineering-bootcamp
git init

# .gitignore
cat << 'EOF' > .gitignore
.venv/
__pycache__/
.ipynb_checkpoints/
*.pyc
.DS_Store
*.log
EOF

🆘 Problèmes Courants

Docker : permission denied

sudo usermod -aG docker $USER
newgrp docker

Spark : Java not found

echo $JAVA_HOME  # Doit afficher un chemin
# Sinon, configurer JAVA_HOME (voir section 2.3)

Jupyter : kernel not found

python -m ipykernel install --user --name=bootcamp --display-name="Python (Bootcamp)"

minikube : not enough memory

minikube delete
minikube start --memory=4096 --cpus=2 --driver=docker

VS Code : Python interpreter not found

Ctrl+Shift+P → “Python: Select Interpreter” → Choisir ~/bootcamp-env/bin/python

🚀 Prêt à démarrer !

🟦 Commencer Niveau 1 🟩 Commencer Niveau 2 🟥 Commencer Niveau 3

🏠 Retour à l’accueil

Retour au sommet