Skip to content
Learni
Voir tous les tutoriels
Big Data

Comment démarrer avec Apache Flink en 2026

12 minBEGINNER
PythonApache FlinkPyFlinkStreamingBig Data
Read in English

Introduction

Apache Flink est un framework open-source distribué de traitement de données qui excelle dans les workloads streaming et batch de manière unifiée. Contrairement à des outils comme Spark qui séparent ces paradigmes, Flink traite les données comme un flux continu infini, avec une gestion d'état robuste, une faible latence et une exactly-once semantics. En 2026, Flink domine les pipelines de données temps réel chez Netflix, Uber ou Alibaba, gérant des téraoctets par seconde.

Ce tutoriel beginner vous guide pour installer Flink localement via PyFlink (API Python), exécuter un job batch WordCount et un job streaming avec socket input. Vous apprendrez les bases : environnement d'exécution, DataStream API, transformations et soumission. À la fin, vous serez prêt à scaler sur un cluster. Chaque exemple est complet et fonctionnel, copier-collable sur votre machine. Imaginez Flink comme un convoyeur industriel : les données entrent en flux, sont transformées en parallèle, et sortent traitées sans perte.

Prérequis

  • Java 11+ installé (OpenJDK recommandé : java -version pour vérifier)
  • Python 3.9+ (avec pip : python --version)
  • Système Unix-like (Linux/Mac) ou WSL sur Windows
  • Accès terminal et éditeur de code (VS Code)
  • Connaissances basiques Python (listes, fonctions)

Installer PyFlink

install.sh
#!/bin/bash

# Vérifier Java
java -version

# Mettre à jour pip
python -m pip install --upgrade pip

# Installer PyFlink (version stable 2026)
pip install apache-flink==1.18.0

# Vérifier installation
python -c "import pyflink; print('PyFlink installé avec succès')"

Ce script vérifie Java (requis pour le runtime JVM de Flink), met à jour pip et installe PyFlink. Il est autonome et s'exécute en une commande. Évitez les versions snapshot pour la stabilité ; testez l'import pour confirmer sans erreur.

Vérifier l'environnement

Exécutez le script install.sh dans un terminal. Vous devriez voir la version Java (11+), l'installation de PyFlink sans warnings, et le message de confirmation. PyFlink lance un mini-cluster JVM localement à chaque job, masquant la complexité du déploiement. Pas besoin de télécharger Flink binary pour débuter.

Premier job batch : WordCount

batch_wordcount.py
from pyflink.datastream import StreamExecutionEnvironment
from pyflink.common.typeinfo import Types
from pyflink.datastream.functions import RuntimeContext

# Créer l'environnement d'exécution (batch par défaut avec collection finie)
env = StreamExecutionEnvironment.get_execution_environment()

# Données d'entrée : liste de phrases
text = ['Hello Flink', 'Welcome to Flink', 'Flink is fast', 'Apache Flink']

# Source : from_collection (batch-like)
ds = env.from_collection(
    collection=text,
    type_info=Types.STRING()
)

# Transformations : flat_map (split mots) -> key_by (grouper par mot) -> sum
# FlatMap pour splitter

def split(line):
    if line:
        for word in line.lower().split():
            yield word, 1

ds = ds.flat_map(split, Types.TUPLE([Types.STRING(), Types.INT()]))

# Grouper par mot et sommer les counts
ds.key_by(lambda x: x[0])\
  .sum(1)\
  .print()

# Exécuter le job
env.execute('Batch WordCount Job')

Ce job batch traite une collection finie de phrases : split en mots, comptage par clé avec key_by et sum. L'environnement local gère 1 task manager par défaut. Copiez-collez et exécutez ; output montre les mots et counts (ex: ('flink', 3)). Piège : Oublier type_info cause des erreurs de sérialisation.

Exécuter le job batch

run_batch.sh
#!/bin/bash

# Créer un fichier Python si pas fait
cat > batch_wordcount.py << EOF
[INSÉRER LE CODE Python CI-DESSUS ICI - OMITTED FOR BREVITY IN PROMPT]
EOF

# Exécuter le job localement
python batch_wordcount.py

# Output attendu :
# ('apache', 1)
# ('fast', 1)
# ('flink', 3)
# etc.

Ce script crée et lance le job. Il démarre un cluster local éphémère (JVM + Python). Observez les logs pour parallelism=1. Pour scaler, set env.set_parallelism(4). Évitez de run sans Java en PATH.

Comprendre le job batch

Le job simule un traitement batch sur données finies. flat_map émet des tuples (mot, 1), key_by groupe, sum agrège. Output en console. Analogie : comme un reduce MapReduce, mais en flux. Ajoutez env.set_parallelism(2) pour voir la distribution.

Job streaming : WordCount socket

stream_wordcount.py
from pyflink.datastream import StreamExecutionEnvironment, TimeCharacteristic
from pyflink.common.time import Time

env = StreamExecutionEnvironment.get_execution_environment()
env.set_stream_time_characteristic(TimeCharacteristic.EventTime)

# Source streaming : socket localhost:9999
stream = env.socket_text_stream('localhost', 9999, delimiter='\n')

# Même transformations
stream.flat_map(lambda line: [(word, 1) for word in line.lower().split() if line])\
      .key_by(lambda x: x[0])\
      .sum(1)\
      .print()

env.execute('Streaming WordCount')

Ce job lit un flux infini depuis un socket TCP. Utilisez EventTime pour timestamps. Transformations identiques au batch, prouvant l'unification Flink. Lancez d'abord un producer socket ; counts s'actualisent en live. Piège : Délai de démarrage socket cause timeout.

Démarrer le producer socket

start_nc.sh
#!/bin/bash

# Installer netcat si besoin (brew install netcat ou apt install netcat)

# Écouter sur port 9999, envoyer lignes
nc -lk 9999

# Dans un autre terminal, tapez des phrases comme :
# Hello Flink
# Flink rocks
# Ctrl+C pour arrêter

Netcat simule un producer streaming. Lancez en premier, puis le job Python. Tapez des lignes ; voyez counts live (ex: ('flink', 2)). Tuez avec Ctrl+C. Sur Windows, utilisez ncat ou PowerShell.

Exécuter le job streaming

run_stream.sh
#!/bin/bash

# Assurer nc en cours (terminal séparé)

# Lancer le job streaming
python stream_wordcount.py

# Tapez dans nc : des mots, observez output :
# ('hello', 1)
# ('flink', 5)
# Job tourne jusqu'à Ctrl+C

Combine producer + consumer. Montre faible latence (<1s). Pour production, remplacez socket par Kafka. Évitez de fermer nc avant ; sinon EOF error.

Bonnes pratiques

  • Toujours spécifier types (Types.STRING(), etc.) pour éviter RuntimeErrors de sérialisation.
  • Set parallelism explicitement : env.set_parallelism(4) pour simuler cluster.
  • Gérez les exceptions dans functions avec try/except pour resilience.
  • Utilisez checkpoints pour fault-tolerance : env.enable_checkpointing(5000).
  • Testez localement avant cluster ; loggez avec logging.getLogger().

Erreurs courantes à éviter

  • Java non trouvé : Ajoutez JAVA_HOME et PATH ; vérifiez java -version.
  • Socket non connecté : Démarrez nc AVANT le job ; utilisez localhost strictement.
  • Types manquants : Flink exige TypeInformation ; cause TypeInformationExtractionException.
  • Pas de yield en flat_map : Utilisez generator (yield) pour multi-émissions.

Pour aller plus loin

  • Documentation officielle : Flink Docs
  • Tutoriel cluster : Téléchargez Flink binary pour standalone.
  • Avancé : Kafka connector, SQL API.
  • Formations Learni : Maîtrisez Flink en production avec nos formations certifiantes.