SageMaker et EMR depuis Airflow : un orchestrateur qui ne calcule rien
Un DAG sur un service géré n’a ni la mémoire ni les droits nécessaires pour un entraînement. Il déclenche, il attend, il alerte quelqu’un, et cette dernière partie est toujours écrite en dernier, souvent après l’incident.
Sur un Airflow géré, la tentation est de faire tourner le calcul dans le DAG : un `PythonOperator` qui charge un jeu de données et entraîne un modèle. Cela fonctionne sur un échantillon et échoue ensuite. Les processus de travail d’un service géré sont dimensionnés pour ordonnancer, pas pour calculer. Ils partagent leur mémoire avec l’ordonnanceur, et un entraînement qui consomme trop bloque l’ordonnancement de toutes les autres chaînes.
Depuis, j’applique une règle simple : l’orchestrateur ne calcule rien. Il décrit un travail, le confie à un service conçu pour l’exécuter, et en surveille le déroulement. Le reste (la taille des machines, les droits, la durée de vie du cluster) devient de la configuration au lieu de code.
Deux cas reviennent. L’entraînement est confié au service de modèles, avec sa propre image et son propre type d’instance. La préparation lourde part sur un cluster éphémère qu’on crée, auquel on soumet des étapes, puis qu’on éteint. Le dernier opérateur, celui de l’extinction, est le plus souvent oublié, et c’est l’oubli le plus coûteux.
from airflow.providers.amazon.aws.operators.emr import (
EmrAddStepsOperator, EmrCreateJobFlowOperator, EmrTerminateJobFlowOperator,
)
from airflow.providers.amazon.aws.operators.sagemaker import SageMakerTrainingOperator
from airflow.providers.amazon.aws.sensors.emr import EmrStepSensor
cluster = EmrCreateJobFlowOperator(task_id="cluster", job_flow_overrides=EMR_CONFIG)
prepare = EmrAddStepsOperator(
task_id="prepare",
job_flow_id=cluster.output,
steps=SPARK_STEPS,
)
# The sensor is what makes the dependency true: without it the next task starts
# as soon as the step is *submitted*, not when it has finished.
wait = EmrStepSensor(
task_id="wait",
job_flow_id=cluster.output,
step_id=prepare.output[0],
mode="reschedule", # gives the slot back instead of holding it
poke_interval=60,
)
training = SageMakerTrainingOperator(
task_id="training",
config=TRAINING_CONFIG,
wait_for_completion=True,
)
shutdown = EmrTerminateJobFlowOperator(
task_id="shutdown",
job_flow_id=cluster.output,
trigger_rule="all_done", # shut down even if the preparation failed
)
cluster >> prepare >> wait >> training
wait >> shutdownDeux détails méritent un paragraphe. Un capteur en mode `reschedule` libère son créneau entre deux vérifications au lieu de l’occuper pendant deux heures. Sur un service géré où les créneaux sont limités et facturés, la différence se voit sur la facture comme sur le débit. Et la règle de déclenchement `all_done` sur l’étape d’extinction est la seule qui garantisse qu’un cluster à plusieurs euros de l’heure ne reste pas allumé après l’échec de l’étape qu’il servait.
Sur un Airflow géré, on ne choisit ni la version des dépendances ni le moment où l’environnement redémarre. Les paquets sont déclarés dans un fichier déposé sur un stockage objet, et toute modification entraîne un redémarrage de l’environnement, soit plusieurs dizaines de minutes sans ordonnancement. En pratique, on n’ajoute donc pas une dépendance à la légère, et on préfère un opérateur du fournisseur à une bibliothèque qu’il faudrait installer.
Un courriel d’échec ne suffit pas comme alerte : personne ne le lit à trois heures du matin. La chaîne qui alimente un modèle en production justifie une astreinte, les autres non. Le choix des chaînes à surveiller compte plus que l’outil : une équipe réveillée pour une chaîne sans conséquence finit par ne plus répondre aux alertes importantes.
from airflow.providers.pagerduty.hooks.pagerduty_events import PagerdutyEventsHook
def page_on_call(context) -> None:
instance = context["task_instance"]
PagerdutyEventsHook(pagerduty_events_conn_id="pagerduty").create_event(
summary=f"{instance.dag_id}.{instance.task_id} failed",
severity="critical",
source="airflow",
# The dedup key avoids opening one incident per attempt: the three tries
# of a single run wake exactly one person.
dedup_key=f"{instance.dag_id}:{instance.task_id}:{context['run_id']}",
custom_details={"log": instance.log_url},
)
# Set on the task that matters, not on the whole DAG: the sorting is what keeps
# an on-call rota credible.
training.on_failure_callback = page_on_callJe ne compare pas les orchestrateurs. Le sujet est intéressant, mais une seule mission ne suffit pas à le trancher. Ce qui a compté ici, c’est la contrainte du service géré, valable quel que soit l’outil. Je ne traite pas non plus la reprise d’un entraînement interrompu : nous relancions depuis le début, ce qui était acceptable à cette échelle et ne l’aurait pas été au-delà.