Pandas & NumPy Academy · Les

Pipelineruns plannen en loggen

Voer uw pipeline als Python-script uit vanaf de opdrachtregel, log begin- en eindtijden en gebruik cron of een scheduler voor automatisering.

Les 4 van 413 stappen

Pipelineruns plannen en loggen is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Pandas & NumPy Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.

Van notebook naar script

Een pipeline die alleen draait wanneer een ontwikkelaar handmatig een notebook opent, levert na de eerste uitvoering geen zakelijke waarde meer. Om de pipeline elke dag automatisch uit te voeren, moet deze zijn opgebouwd als een Python-script dat vanaf de opdrachtregel kan worden uitgevoerd: python pipeline.py. Daarvoor zijn een if __name__ == '__main__':-ingangspunt, het parsen van opdrachtregelargumenten en correcte logging nodig — de drie pijlers van een productiescript.

# 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)

Python-logging configureren

De ingebouwde Python-module logging is het juiste hulpmiddel voor pipelinelogs — niet print(). Configureer een logger met zowel uitvoer naar de console als naar een bestand met logging.basicConfig(). Gebruik het niveau INFO voor normale voortgang en ERROR voor fouten. Logs in bestanden blijven bestaan nadat het proces is beëindigd. Dat is essentieel voor het debuggen van geplande uitvoeringen die niemand in de gaten hield.

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.')

Het begin en einde van de pipeline loggen

Log altijd de begintijd, eindtijd en verstreken tijd van een pipeline-uitvoering. Zo leg je een referentiepunt vast: als de pipeline normaal 45 seconden duurt en vandaag 8 minuten nodig had, is er iets veranderd — misschien is het invoerbestand 10× groter of wordt een databasequery langzaam uitgevoerd. Tijdstempels bij het begin en einde maken deze vergelijking eenvoudig, alleen op basis van het logbestand.

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)
        raise

Aantal rijen per stap loggen

Log het aantal rijen dat elke transformatiestap binnenkomt en verlaat. Een duidelijk log ziet er bijvoorbeeld zo uit: extract: 50.000 rijen → drop_nulls: 49.200 rijen → filter: 47.800 rijen → output: 47.800 rijen. Met deze tracering zie je onmiddellijk hoeveel rijen bij elke stap zijn verwijderd en of de aantallen kloppen. Afwijkende afnames vallen op als hiaten in de gelogde aantallen.

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.')

Plannen met cron op Linux/Mac

cron is de standaardplanner van Unix voor terugkerende taken. Bewerk de crontab met crontab -e en voeg een regel toe die aangeeft wanneer het script moet worden uitgevoerd. De indeling is: minuut uur dag maand weekdag opdracht. Een pipeline die elke dag om 6:00 uur moet draaien, gebruikt 0 6 * * * /usr/bin/python /path/to/pipeline.py. Gebruik in cronregels altijd absolute paden, omdat cron in een minimale omgeving draait zonder de PATH-instellingen van je 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')

Plannen met de Python-bibliotheek schedule

De bibliotheek schedule biedt een manier in puur Python om taken op opgegeven intervallen uit te voeren zonder cron te gebruiken. Dit is handig in omgevingen waar cron niet beschikbaar is (Windows) of wanneer je de planningslogica in het Python-proces zelf wilt opnemen. Plaats de pipeline in een geplande taaklus en houd het proces actief om de taak herhaaldelijk uit te voeren.

# 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')

Foutafhandeling en afsluitcodes

Een pipelinescript moet een afsluitcode die niet nul is retourneren wanneer het mislukt, zodat de planner weet dat de taak is mislukt. Plaats de hoofdprogramma-uitvoering in een try/except-blok en roep bij een fout sys.exit(1) aan. cron, Jenkins en Airflow controleren de afsluitcode: een code die niet nul is, activeert een waarschuwing, nieuwe uitvoering of melding. Een onverwerkte uitzondering waarbij de afsluitcode niet wordt ingesteld, kan onopgemerkt blijven door geautomatiseerde monitoring.

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')

Een samenvattingsbestand voor een pipeline-uitvoering schrijven

Schrijf na een geslaagde uitvoering een klein JSON-samenvattingsbestand naast de uitvoer. Neem het tijdstip van de uitvoering, het aantal invoerrijen, het aantal uitvoerrijen, het aantal verwijderde rijen en de verstreken tijd op. Monitoringssystemen en dashboards kunnen dit bestand lezen om trends in de pipelinegezondheid in de loop van de tijd te volgen. Met een dashboard dat het aantal uitvoerrijen van de afgelopen 30 dagen toont, zie je eenvoudig op welke dag een gegevensbron minder records begon te leveren.

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.')

Idempotent plannen: dubbele uitvoeringen voorkomen

Als een geplande pipeline per ongeluk twee keer wordt gestart, mag de uitvoer niet beschadigd raken. Ontwerp de laadstap idempotent: gebruik een gedateerde bestandsnaam voor de uitvoer of overschrijf dezelfde uitvoer met het nieuwste resultaat. Gebruik voor het laden in databases if_exists='replace' of een UPSERT-patroon. Gebruik nooit de modus append zonder een deduplicatiestap, want elke geplande uitvoering voegt dan dubbele rijen toe aan de uitvoertabel.

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}')

Waarschuwen bij een fout in de pijplijn

Voor pijplijnen waarvan bedrijfsactiviteiten afhankelijk zijn, is stilte na een fout gevaarlijk. Stel een eenvoudige waarschuwing in: als het bestand met het uitvoeroverzicht niet binnen het verwachte tijdsvenster wordt bijgewerkt, stuur dan een e-mail of Slack-bericht. Met Python's smtplib kunt u bij een fout een e-mail versturen, of u kunt een webhook gebruiken om een bericht naar Slack te plaatsen. Waarschuw onmiddellijk bij afsluitcode 1 of 2, zodat de analist weet dat de dagelijkse vernieuwing is mislukt voordat het bedrijf dat merkt.

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.')

Volledig script voor een geplande pijplijn

Combineer alle onderdelen — argumenten verwerken, logging configureren, een uitvoeroverzicht, foutafhandeling en afsluitcodes — tot een volledig pijplijnscript. U kunt dit script in elke omgeving plaatsen, naar een configuratiebestand laten verwijzen en met cron of een workfloworkestrator plannen. Bij elke uitvoering maakt het een gedateerd logbestand, een uitvoeroverzicht en een gedateerd uitvoerbestand, zodat elke uitvoering volledig controleerbaar en onafhankelijk reproduceerbaar is.

# 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')

Korte controle

Test uw begrip van de concepten uit Data Analysis in deze les.

Samenvatting van de les

In deze les hebt u geleerd hoe u: een pijplijn structureert als een opdrachtregel-script met verwerking van argumenten en logging, taken plant met cron en fouten afhandelt met niet-nul afsluitcodes en waarschuwingen, en bestanden met uitvoeroverzichten schrijft en idempotente laadstappen ontwerpt voor betrouwbare geautomatiseerde uitvoering. Gefeliciteerd met het voltooien van het traject Data Analysis: Pandas and NumPy!

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “Pipelineruns plannen en loggen” gratis?

Ja — de volledige tekst van “Pipelineruns plannen en loggen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Pandas & NumPy Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.

Wat leer ik in “Pipelineruns plannen en loggen”?

Voer uw pipeline als Python-script uit vanaf de opdrachtregel, log begin- en eindtijden en gebruik cron of een scheduler voor automatisering. Je oefent met Pandas & NumPy Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Pandas & NumPy Academy te beginnen?

Ervaring vooraf is niet nodig. Pandas & NumPy Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Pipelineruns plannen en loggen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Pandas & NumPy Academy?

Ja. Elke les over Pandas & NumPy Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Transformaties structureren als functies
  2. Pipelines parametriseren met config-dicts
  3. Pipelinestappen testen met assertions
  4. Pipelineruns plannen en loggen
← Terug naar Pandas & NumPy Academy