Pandas & NumPy Academy · Lektion

Schemaläggning och loggning av pipelinekörningar

Kör Er pipeline som ett Python-skript från kommandoraden, logga start- och sluttider och använd cron eller en schemaläggare för automatisering.

Lektion 4 av 413 steg

Schemaläggning och loggning av pipelinekörningar är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Från notebook till skript

En pipeline som bara körs när en utvecklare manuellt öppnar en notebook ger inget större verksamhetsvärde efter den första körningen. För att köras automatiskt varje dag måste pipelinen struktureras som ett Python-skript som kan köras från kommandoraden: python pipeline.py. Det kräver en startpunkt med if __name__ == '__main__':, tolkning av kommandoradsargument och korrekt loggning – de tre grundpelarna i ett produktionsskript.

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

Konfigurera Python-loggning

Pythons inbyggda modul logging är rätt verktyg för pipelineloggar – inte print()-satser. Konfigurera en logger med både utdata till konsolen och utdata till fil med logging.basicConfig(). Logga på nivån INFO för normala förlopp och ERROR för fel. Filbaserade loggar finns kvar efter att processen avslutats, vilket är avgörande vid felsökning av schemalagda körningar som ingen övervakade.

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

Logga pipelinekörningens start och slut

Logga alltid starttid, sluttid och förfluten tid för en pipelinekörning. Det skapar en referenspunkt: om pipelinen normalt körs på 45 sekunder men tog 8 minuter i dag har något förändrats – kanske är indatafilen 10× större eller så körs en databasfråga långsamt. Tidsstämplade loggposter för start och slut gör det enkelt att jämföra detta direkt i loggfilen.

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

Logga radantal per steg

Logga radantalet som kommer in i och lämnar varje transformationssteg. En tydlig logg kan se ut så här: extract: 50,000 rows → drop_nulls: 49,200 rows → filter: 47,800 rows → output: 47,800 rows. Med den här spårningen blir det direkt tydligt hur många rader som togs bort i varje steg och om siffrorna är förväntade. Avvikande bortfall syns som luckor i de loggade antalen.

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

Schemaläggning med cron i Linux/Mac

cron är Unix-standardschemaläggaren för återkommande jobb. Redigera crontab med crontab -e och lägg till en rad som anger när skriptet ska köras. Formatet är: minute hour day month weekday command. En pipeline som måste köras klockan 06.00 varje dag använder 0 6 * * * /usr/bin/python /path/to/pipeline.py. Använd alltid absoluta sökvägar i cron-poster, eftersom cron körs i en begränsad miljö utan skalets PATH-inställningar.

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

Schemaläggning med Python-biblioteket schedule

Biblioteket schedule erbjuder ett sätt att köra jobb med angivna intervall, helt i Python och utan att använda cron. Det är användbart i miljöer där cron inte är tillgängligt (Windows) eller när ni vill ha schemaläggningslogiken inne i själva Python-processen. Omslut pipelinen i en schemalagd jobbslinga och låt processen fortsätta köras så att jobbet kan utföras upprepade gånger.

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

Felhantering och avslutskoder

Ett pipelineskript bör returnera en avslutskod som inte är noll när det misslyckas, så att schemaläggaren vet att jobbet misslyckades. Omslut huvudkörningen i ett try/except-block och anropa sys.exit(1) vid fel. cron, Jenkins och Airflow kontrollerar alla avslutskoden: en kod som inte är noll utlöser en avisering, en ny körning eller en notifikation. Ett ohanterat undantag som inte anger avslutskoden kan förbli oupptäckt av automatiserad övervakning.

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

Skriv en sammanfattningsfil för pipelinekörningen

Skriv efter en lyckad körning en liten JSON-sammanfattningsfil bredvid resultatet. Ta med tidsstämpel för körningen, antal rader i indata, antal rader i utdata, antal borttagna rader och förfluten tid. Övervakningssystem och instrumentpaneler kan läsa den här filen för att följa trender i pipelinens hälsa över tid. En instrumentpanel som visar antalet utdataposter under de senaste 30 dagarna gör det enkelt att se vilken dag en datakälla började leverera färre poster.

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 schemaläggning: undvik dubbla körningar

Om en schemalagd pipeline råkar startas två gånger ska den inte förstöra resultatet. Utforma laddningssteget så att det är idempotent: använd ett daterat filnamn för resultatet eller skriv över samma resultat med den senaste körningen. För databasladdningar kan ni använda if_exists='replace' eller ett UPSERT-mönster. Använd aldrig läget append utan ett dedupliceringssteg, annars lägger varje schemalagd körning till duplicerade rader i resultattabellen.

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

Aviseringar vid pipelinefel

För pipelines som verksamheten är beroende av är tystnad efter ett fel farlig. Konfigurera en enkel avisering: om filen med körningssammanfattningen inte uppdateras inom det förväntade tidsintervallet skickar ni ett e-postmeddelande eller ett Slack-meddelande. Pythons smtplib kan skicka ett e-postmeddelande vid fel, eller så kan ni använda en webhook för att publicera ett meddelande i Slack. Skicka en avisering direkt vid avslutskod 1 eller 2, så att analytikern vet att den dagliga uppdateringen misslyckades innan verksamheten upptäcker det.

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

Färdigt skript för schemalagd pipeline

Slå ihop alla delar — argumenttolkning, loggningskonfiguration, körningssammanfattning, felhantering och avslutskoder — till ett komplett pipelineskript. Skriptet kan läggas in i valfri miljö, kopplas till en konfigurationsfil och schemaläggas med cron eller valfri arbetsflödesorkestrerare. Vid varje körning skapar det en daterad loggfil, en körningssammanfattning och en daterad utdatafil, vilket gör varje körning fullt granskningsbar och oberoende reproducerbar.

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

Snabbtest

Testa era kunskaper om dataanalys från den här lektionen.

Sammanfattning av lektionen

I den här lektionen har ni lärt er: att strukturera en pipeline som ett kommandoradsskript med argumenttolkning och loggning, att schemalägga med cron och hantera fel med avslutskoder som inte är noll samt aviseringar, och att skriva filer med körningssammanfattningar och utforma idempotenta laddningssteg för tillförlitlig automatiserad körning. Grattis till att ni har slutfört spåret Dataanalys: Pandas och NumPy!

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Schemaläggning och loggning av pipelinekörningar” gratis?

Ja – hela texten till ”Schemaläggning och loggning av pipelinekörningar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Schemaläggning och loggning av pipelinekörningar”?

Kör Er pipeline som ett Python-skript från kommandoraden, logga start- och sluttider och använd cron eller en schemaläggare för automatisering. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Schemaläggning och loggning av pipelinekörningar”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Strukturera transformeringssteg som funktioner
  2. Parameterisera pipelines med config-dict
  3. Testa pipelinesteg med assertions
  4. Schemaläggning och loggning av pipelinekörningar
← Tillbaka till Pandas & NumPy Academy