Pandas & NumPy Academy · leksjon

Planlegge og loggføre pipelinekjøringer

Kjør pipelinen som et Python-skript fra kommandolinjen, loggfør start- og sluttidspunkt, og bruk cron eller en planlegger til automatisering.

Leksjon 4 av 413 trinn

Planlegge og loggføre pipelinekjøringer er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Fra notebook til skript

En pipeline som bare kjører når en utvikler åpner en notebook manuelt, gir ingen forretningsverdi utover den første kjøringen. For å kjøre automatisk hver dag må pipelinen struktureres som et Python-skript som kan kjøres fra kommandolinjen: python pipeline.py. Dette krever et if __name__ == '__main__':-inngangspunkt, behandling av kommandolinjeargumenter og riktig logging – de tre grunnpilarene i et produksjonsskript.

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

Konfigurere Python-logging

Den innebygde Python-modulen logging er riktig verktøy for pipelinelogger – ikke print()-setninger. Konfigurer en logger med både konsoll- og filutdata ved hjelp av logging.basicConfig(). Logg på nivået INFO for normal fremdrift og ERROR ved feil. Filbaserte logger bevares etter at prosessen avsluttes, noe som er avgjørende for feilsøking av planlagte kjøringer som ingen fulgte med på.

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

Logge start og slutt for pipelinen

Logg alltid starttidspunkt, sluttidspunkt og medgått tid for en pipeline-kjøring. Dette etablerer et utgangspunkt: Hvis pipelinen vanligvis kjører på 45 sekunder, men i dag brukte 8 minutter, har noe endret seg – kanskje inndatafilen er 10× større, eller et databasespørring kjører sakte. Tidsstemplete loggoppføringer for start og slutt gjør denne sammenligningen enkel, kun ved hjelp av 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

Logge radantall for hvert trinn

Logg radantallet som kommer inn i og går ut av hvert transformasjonstrinn. En oversiktlig logg kan se slik ut: extract: 50,000 rows → drop_nulls: 49,200 rows → filter: 47,800 rows → output: 47,800 rows. Dette sporet viser umiddelbart hvor mange rader som ble fjernet i hvert trinn, og om tallene er som forventet. Uvanlig store reduksjoner vises som avvik i de loggførte tallene.

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

Planlegging med cron på Linux/Mac

cron er standardplanleggeren i Unix for gjentakende jobber. Rediger crontab med crontab -e og legg til en linje som angir når skriptet skal kjøres. Formatet er: minutt time dag måned ukedag kommando. En pipeline som skal kjøre kl. 06:00 hver dag, bruker 0 6 * * * /usr/bin/python /path/to/pipeline.py. Bruk alltid absolutte stier i cron-oppføringer, fordi cron kjører i et minimalt miljø uten PATH-innstillingene fra skallet.

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

Planlegging med Python-biblioteket schedule

schedule-biblioteket tilbyr en måte å kjøre jobber med angitte intervaller på, utelukkende ved hjelp av Python og uten å berøre cron. Det er nyttig i miljøer der cron ikke er tilgjengelig (Windows), eller når De ønsker planleggingslogikken inne i selve Python-prosessen. Pakk inn pipelinen i en planlagt jobbløkke, og la prosessen kjøre slik at jobben kan utføres gjentatte ganger.

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

Feilhåndtering og avslutningskoder

Et pipelineskript bør returnere en avslutningskode som ikke er null, når det mislykkes, slik at planleggeren vet at jobben feilet. Pakk hovedkjøringen inn i en try/except-blokk, og kall sys.exit(1) ved feil. cron, Jenkins og Airflow kontrollerer alle avslutningskoden: En kode som ikke er null, utløser et varsel, en ny kjøring eller en varsling. Et ubehandlet unntak som ikke setter avslutningskoden, kan gå ubemerket hen av automatisert overvåking.

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

Skrive en sammendragsfil for pipeline-kjøringen

Etter en vellykket kjøring bør De skrive en liten JSON-sammendragsfil ved siden av resultatet. Ta med tidspunktet for kjøringen, antall rader i inndataene, antall rader i resultatet, antall fjernede rader og medgått tid. Overvåkingssystemer og kontrollpaneler kan lese denne filen for å følge utviklingen i pipeline-helsen over tid. Et kontrollpanel som viser resultatrader de siste 30 dagene, gjør det enkelt å oppdage dagen da en datakilde begynte å levere 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 planlegging: Unngå doble kjøringer

Hvis en planlagt pipeline startes to ganger ved et uhell, bør den ikke ødelegge resultatet. Utform lastetrinnet slik at det er idempotent: Bruk et datert filnavn for resultatet, eller overskriv det samme resultatet med den nyeste versjonen. Ved lasting til databaser kan De bruke if_exists='replace' eller et UPSERT-mønster. Bruk aldri append-modus uten et dedupliseringstrinn, ellers vil hver planlagte kjøring legge til dupliserte 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}')

Varsling ved feil i pipeline

For pipelines som virksomheten er avhengig av, er stillhet etter en feil farlig. Sett opp et enkelt varsel: Hvis filen med kjøringsoppsummeringen ikke blir oppdatert innenfor det forventede tidsvinduet, sender De en e-post eller Slack-melding. Python's smtplib kan sende en e-post ved feil, eller De kan bruke en webhook til å publisere en melding i Slack. Varsle umiddelbart ved avslutningskode 1 eller 2, slik at analytikeren vet at den daglige oppdateringen uteble før virksomheten oppdager 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.')

Fullstendig planlagt pipelineskript

Kombiner alle delene — argumenttolking, loggkonfigurasjon, kjøringsoppsummering, feilhåndtering og avslutningskoder — til et fullstendig pipelineskript. Dette skriptet kan tas i bruk i ethvert miljø, kobles til en konfigurasjonsfil og planlegges med cron eller en hvilken som helst arbeidsflytorkestrator. Det produserer en datert loggfil, en kjøringsoppsummering og en datert utdatafil ved hver kjøring, slik at hver kjøring kan revideres fullstendig og gjenskapes uavhengig.

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

Hurtigsjekk

Test forståelsen Deres av konseptene innen dataanalyse fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen har De lært: å strukturere en pipeline som et kommandolinjeskript med argumenttolking og logging, å planlegge kjøringer med cron og håndtere feil med avslutningskoder som ikke er null, samt varsler, og å skrive filer med kjøringsoppsummeringer og utforme idempotente innlastingstrinn for pålitelig automatisert kjøring. Gratulerer med å ha fullført sporet Data Analysis: Pandas and NumPy!

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120

Ofte stilte spørsmål

Er leksjonen «Planlegge og loggføre pipelinekjøringer» gratis?

Ja – hele teksten i «Planlegge og loggføre pipelinekjøringer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Planlegge og loggføre pipelinekjøringer»?

Kjør pipelinen som et Python-skript fra kommandolinjen, loggfør start- og sluttidspunkt, og bruk cron eller en planlegger til automatisering. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?

Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Planlegge og loggføre pipelinekjøringer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?

Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Strukturere transformasjonstrinn som funksjoner
  2. Parameterisere pipelines med config-dictionaries
  3. Teste pipelinetrinn med assertions
  4. Planlegge og loggføre pipelinekjøringer
← Tilbake til Pandas & NumPy Academy