Programar y registrar ejecuciones del pipeline
Ejecute su pipeline como un script de Python desde la línea de comandos, registre las horas de inicio y finalización, y use cron o un programador para automatizarlo.
Programar y registrar ejecuciones del pipeline es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
Del notebook al script
Un pipeline que solo se ejecuta cuando un desarrollador abre manualmente un notebook no aporta ningún valor empresarial más allá de la primera ejecución. Para ejecutarse automáticamente cada día, el pipeline debe estructurarse como un script de Python ejecutable desde la línea de comandos: python pipeline.py. Esto requiere un punto de entrada if __name__ == '__main__':, análisis de argumentos de la línea de comandos y un registro adecuado; estos son los tres pilares de un script de producción.
# pipeline.py
import argparse
import logging
import pandas as pd
def main(config_path):
logging.info(f'Starting pipeline with config: {config_path}')
# ... run ETL steps ...
logging.info('Pipeline complete.')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--config', default='config.json')
args = parser.parse_args()
main(args.config)Configuración del registro de Python
El módulo integrado logging de Python es la herramienta adecuada para los registros del pipeline, no las instrucciones print(). Configure un logger con salida tanto en la consola como en un archivo mediante logging.basicConfig(). Registre el progreso normal en el nivel INFO y los fallos en el nivel ERROR. Los registros basados en archivos persisten después de que finaliza el proceso, lo cual es esencial para depurar ejecuciones programadas que nadie estaba supervisando.
import logging
from datetime import date
log_file = f'pipeline_{date.today()}.log'
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s',
handlers=[
logging.FileHandler(log_file),
logging.StreamHandler()
]
)
logging.info('Logger configured.')Registro del inicio y el final del pipeline
Registre siempre la hora de inicio, la hora de finalización y el tiempo transcurrido de una ejecución del pipeline. Esto establece una referencia: si normalmente el pipeline tarda 45 segundos y hoy tardó 8 minutos, algo ha cambiado; quizá el archivo de entrada sea 10 veces más grande o una consulta a la base de datos se esté ejecutando lentamente. Las entradas de registro de inicio y finalización con marca de tiempo hacen que esta comparación sea trivial utilizando únicamente el archivo de registro.
import time
import logging
def run_pipeline(config):
start = time.time()
logging.info(f'Pipeline START | env={config.get("env", "dev")} | input={config["input_path"]}')
try:
df = extract(config)
df_clean = transform(df, config)
load(df_clean, config)
elapsed = time.time() - start
logging.info(f'Pipeline SUCCESS | rows={len(df_clean)} | elapsed={elapsed:.1f}s')
except Exception as e:
logging.error(f'Pipeline FAILED | error={e}', exc_info=True)
raiseRegistro del número de filas de cada paso
Registre el número de filas que entran y salen de cada paso de transformación. Un registro claro tiene este aspecto: extract: 50,000 rows → drop_nulls: 49,200 rows → filter: 47,800 rows → output: 47,800 rows. Esta traza muestra de inmediato cuántas filas se eliminaron en cada paso y si las cifras son las esperadas. Las eliminaciones anómalas aparecen como saltos en los recuentos registrados.
def log_step(df, step_name):
logging.info(f'{step_name}: {len(df):,} rows')
return df
import pandas as pd
df = (pd.read_csv('orders.csv')
.pipe(log_step, 'extract')
.dropna(subset=['revenue'])
.pipe(log_step, 'drop_nulls')
.query('quantity > 0')
.pipe(log_step, 'filter_qty')
)
print('Step logging complete.')Programación con cron en Linux/Mac
cron es el programador estándar de Unix para trabajos recurrentes. Edite el crontab con crontab -e y añada una línea que especifique cuándo ejecutar el script. El formato es: minuto hora día mes día_de_la_semana comando. Un pipeline que deba ejecutarse todos los días a las 6:00 utiliza 0 6 * * * /usr/bin/python /path/to/pipeline.py. Utilice siempre rutas absolutas en las entradas de cron, porque cron se ejecuta en un entorno mínimo sin la configuración de PATH de su shell.
# crontab entry — edit with: crontab -e
# Run pipeline.py at 06:00 every day
# 0 6 * * * /opt/homebrew/bin/python /Users/analyst/pipeline.py --config /Users/analyst/config.json >> /Users/analyst/cron.log 2>&1
# Common cron patterns:
# 0 6 * * * — daily at 06:00
# 0 */4 * * * — every 4 hours
# 0 9 * * 1 — every Monday at 09:00
print('Cron schedule format: minute hour day month weekday')Programación con la biblioteca schedule de Python
La biblioteca schedule proporciona una forma basada exclusivamente en Python de ejecutar trabajos a intervalos especificados sin utilizar cron. Resulta útil en entornos donde cron no está disponible (Windows) o cuando desea mantener la lógica del programador dentro del propio proceso de Python. Coloque el pipeline en un bucle de trabajo programado y mantenga el proceso activo para ejecutarlo repetidamente.
# pip install schedule
# import schedule, time
# def job():
# logging.info('Scheduled run starting...')
# run_pipeline(CONFIG)
# schedule.every().day.at('06:00').do(job)
# schedule.every(4).hours.do(job)
# while True:
# schedule.run_pending()
# time.sleep(60)
print('schedule library: use for in-process Python scheduling')Gestión de errores y códigos de salida
Un script de pipeline debe devolver un código de salida distinto de cero cuando falla, para que el programador sepa que el trabajo ha fallado. Incluya la ejecución principal en un bloque try/except y llame a sys.exit(1) en caso de error. cron, Jenkins y Airflow comprueban el código de salida: un código distinto de cero activa una alerta, una nueva ejecución o una notificación. Una excepción no controlada que no establezca el código de salida puede pasar desapercibida para la supervisión automatizada.
import sys
def main():
try:
run_pipeline(CONFIG)
sys.exit(0) # success
except AssertionError as e:
logging.error(f'Data validation failed: {e}')
sys.exit(2) # data error
except Exception as e:
logging.error(f'Unexpected error: {e}', exc_info=True)
sys.exit(1) # general failure
print('Exit code 0=success, 1=error, 2=data failure')Escritura de un archivo de resumen de la ejecución del pipeline
Después de una ejecución correcta, escriba un pequeño archivo de resumen JSON junto a la salida. Incluya la marca de tiempo de la ejecución, el número de filas de entrada, el número de filas de salida, las filas eliminadas y el tiempo transcurrido. Los sistemas de supervisión y los paneles pueden leer este archivo para seguir la evolución del estado del pipeline a lo largo del tiempo. Un panel que muestre las filas de salida de los últimos 30 días facilita detectar el día en que una fuente de datos empezó a entregar menos registros.
import json
from datetime import datetime
def write_run_summary(config, input_rows, output_rows, elapsed):
summary = {
'run_at': datetime.now().isoformat(),
'input_path': config['input_path'],
'input_rows': input_rows,
'output_rows': output_rows,
'rows_dropped': input_rows - output_rows,
'elapsed_seconds': round(elapsed, 2),
'status': 'success'
}
with open('last_run_summary.json', 'w') as f:
json.dump(summary, f, indent=2)
print('Run summary written.')Programación idempotente: evitar ejecuciones duplicadas
Si un pipeline programado se activa dos veces por accidente, no debe corromper la salida. Diseñe el paso de carga para que sea idempotente: utilice un nombre de archivo de salida con la fecha o sobrescriba la misma salida con el resultado más reciente. Para las cargas en bases de datos, utilice if_exists='replace' o un patrón UPSERT. Nunca utilice el modo append sin un paso de eliminación de duplicados, ya que cada ejecución programada añadirá filas duplicadas a la tabla de salida.
from datetime import date
def load_idempotent(df, config):
# Date-stamped output: each run overwrites its own day's file
output_path = f"output_{date.today().strftime('%Y%m%d')}.parquet"
df.to_parquet(output_path, index=False)
logging.info(f'Loaded {len(df)} rows to {output_path}')Alertas ante fallos del pipeline
En los pipelines de los que dependen las operaciones empresariales, que no haya ninguna señal después de un fallo es peligroso. Configure una alerta sencilla: si el archivo de resumen de ejecución no se actualiza dentro del intervalo esperado, envíe un correo electrónico o un mensaje de Slack. smtplib de Python puede enviar un correo electrónico cuando se produce un fallo, o puede usar un webhook para publicar un mensaje en Slack. Genere una alerta inmediatamente ante un código de salida 1 o 2 para que la persona analista sepa que la actualización diaria no se ha realizado antes de que la empresa lo detecte.
import smtplib
def send_failure_alert(error_msg):
# Example: send plain-text email via SMTP
# server = smtplib.SMTP('smtp.example.com', 587)
# server.sendmail('pipeline@company.com',
# 'analyst@company.com',
# f'Subject: Pipeline Failed\n\n{error_msg}')
# server.quit()
print(f'[ALERT] Would send failure notification: {error_msg}')
# In main():
# except Exception as e:
# send_failure_alert(str(e))
# sys.exit(1)
print('Alert integration pattern shown above.')Script completo de un pipeline programado
Combine todas las piezas —parseo de argumentos, configuración del registro, resumen de ejecución, gestión de errores y códigos de salida— en un script de pipeline completo. Puede incorporar este script en cualquier entorno, indicarle un archivo de configuración y programarlo con cron o con cualquier orquestador de flujos de trabajo. En cada ejecución genera un archivo de registro fechado, un resumen de ejecución y un archivo de salida fechado, lo que hace que cada ejecución sea completamente auditable y reproducible de forma independiente.
# Full script skeleton:
# 1. parse --config argument
# 2. configure logging to file + console
# 3. load JSON config
# 4. validate config
# 5. run extract() -> transform() -> load()
# 6. write run summary JSON
# 7. sys.exit(0) on success, sys.exit(1) on failure
print('Production pipeline script structure complete.')
print('Schedule with: crontab -e or python scheduler.py')Comprobación rápida
Compruebe su comprensión de los conceptos de Análisis de datos de esta lección.
Recapitulación de la lección
En esta lección ha aprendido: estructurar un pipeline como un script de línea de comandos con parseo de argumentos y registro, programar tareas con cron y gestionar fallos mediante códigos de salida distintos de cero y alertas, y escribir archivos de resumen de ejecución y diseñar pasos de carga idempotentes para una ejecución automatizada fiable. ¡Enhorabuena por completar el itinerario de Análisis de datos: Pandas y NumPy!
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «Programar y registrar ejecuciones del pipeline» es gratis?
Sí — el texto completo de «Programar y registrar ejecuciones del pipeline» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Programar y registrar ejecuciones del pipeline»?
Ejecute su pipeline como un script de Python desde la línea de comandos, registre las horas de inicio y finalización, y use cron o un programador para automatizarlo. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Programar y registrar ejecuciones del pipeline»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Estructurar los pasos de transformación como funciones
- Parametrizar pipelines con diccionarios de configuración
- Probar los pasos del pipeline con aserciones
- Programar y registrar ejecuciones del pipeline