{"canonical_url":"https://engineer.company/sv/glossary/pipeline/","content_markdown":"# Datapipeline\n\n## Vad det är\n\nEn datapipeline, ofta bara kallad pipeline, är en uppsättning jobb som körs i en fast ordning, där\nvarje jobb tar emot det som jobbet före producerade, så att råa poster från de system som skapar dem\nhamnar rensade, sammanfogade och lagrade där rapporter, dashboards eller andra program kan läsa dem.\nNamnet kommer från Unix-skalet, där `|` matar utdata från ett kommando in i nästa. De flesta\npipelines körs utan tillsyn, enligt ett schema eller så fort en ny fil kommer in.\n\nFå pipelines är en rak linje. Ett jobb som läser in dagens försäljning kan behöva både\nvalutakurserna och kundlistan först, medan de två kan köras sida vid sida. Jobben och pilarna för\n”måste bli klart först” mellan dem bildar en riktad acyklisk graf: varje pil pekar åt ett håll, och\nett jobb kan aldrig hamna i att vänta på sig självt. Apache Airflow, en plattform med öppen källkod\nför att schemalägga och övervaka sådana arbetsflöden, kallar varje graf för en Dag, skrivet så och\ninte DAG eftersom betydelsen i Airflow har vuxit förbi den rena matematiska strukturen.\n\nEn batchpipeline vaknar enligt ett schema eller vid en händelse, bearbetar en avgränsad del av\ndatan, till exempel ett dygns mätaravläsningar, och stannar. En strömmande pipeline fortsätter att\nköras och skickar vidare varje händelse när den kommer in. Airflow beskriver sig som en plattform\nför att orkestrera batcharbetsflöden, bäst lämpad för arbete med en tydlig början och ett tydligt\nslut som körs enligt ett schema.\n\nDen enklaste pipelinen är en rad i en crontab som startar ett skript klockan två på natten. Det\nhåller tills flera skript måste köras i ordning, ett av dem går sönder och någon måste reda ut vilka\nsom kördes och vad som ska startas om. En orkestrerare tar över den bokföringen: den håller grafen,\nstartar varje jobb när jobben uppströms har lyckats, gör om de jobb som går sönder, sparar en logg\nper jobb och per körning och noterar vilka perioder av data varje körning täckte. I Airflow täcker\nvarje schemalagd körning ett dataintervall. En daglig körning för den 1 januari startar strax efter\nmidnatt den 2 januari, när dygnet är slut, och dess jobb kan läsa gränser som `data_interval_start`\nför att veta exakt vilken del av datan som är deras.\n\n## Varför det spelar roll\n\nEn pipeline gör en rutin till kod. Ordningen mellan jobben, kontrollerna mellan dem, vad som händer\nnär ett går sönder och hur ofta allt körs flyttar ut ur en enskild persons minne och in i filer som\nkan granskas, versionshanteras och testas som all annan programvara. Airflow definierar sina\narbetsflöden helt i Python, ett angreppssätt som projektet kallar workflows as code, och räknar\nversionshantering och testning bland fördelarna.\n\nEtt fel får också en adress. När hela processen är ett långt skript betyder en krasch vid minut\nfyrtio att man börjar om från minut noll. Uppdelad i jobb med sparat tillstånd visar en trasig\nkörning vilket jobb som stannade och varför, och bara det jobbet och de efter det behöver köras\nigen. Airflow låter en operatör köra om enbart de misslyckade uppgifterna, eller fylla i körningar i\nefterhand för en tidigare period, och det är så en rättning som görs på onsdagen når måndagens data.\n\nUpprepning blir säker först när varje jobb är skrivet för den. Guiden Best Practices i\nAirflow-dokumentationen ber att varje uppgift beter sig som en databastransaktion som aldrig lämnar\nhalvfärdiga resultat efter sig, och att den ger samma utfall vid varje omkörning. Ett jobb som är\nbyggt så, ett idempotent jobb, kan göras om av schemaläggaren klockan tre på natten, köras om efter\nen rättning eller spelas upp igen för förra månaden, utan att någon först behöver granska målet.\n\nPriset är programvara att äga. En orkestrerare är ytterligare en tjänst med egen databas, egna\nuppgraderingar och egna behörigheter, och varje pipeline i den är kod som behöver granskning och\ntester. För två skript på samma schema kan cron och en loggfil vara det ärliga svaret. Argumenten\nför en orkestrerare växer med antalet jobb som beror på varandra, antalet personer som behöver se\nvad som kördes och kostnaden för en morgonrapport som bygger på en inläsning som stannade halvvägs.\n\n## Så ser det ut i praktiken\n\nTjugo pipelines som måste bete sig likadant, en som måste tåla att köras om och en som måste vara\nsnabb ställer tre olika krav på samma sorts kedja.\n\nPå en plattform levererades och övervakades\n[tjugo GIS-datapipelines och ETL-flödet för applikationsdata](/sv/portfolio/automated-delivery-of-20-gis-data-pipelines/)\nför hand, med en ständig risk att en av dem skulle stanna i det tysta och lämna fel data längre ned\ni kedjan innan någon märkte det. Alla fick automatiserad leverans, med schemaläggning, loggning och\nfelhantering standardiserade så att varje pipeline betedde sig likadant och så att det syntes när en\ngick sönder, och de lades in i den befintliga infrastrukturautomatiseringen och rapporteringen. Alla\ntjugo kördes sedan automatiskt och förutsägbart, med aktuella data och utan att någon behövde lotsa\ndem igenom för hand.\n\nEn pipeline kan också bygga något komplett med ett enda kommando. I ett\ndokumenterat utvecklingsskede hämtade en\n[databasdriven generator för CV och portfolio](/sv/portfolio/built-a-database-driven-cv-generator/)\nvarje dokument ur en enda SQLite-databas med 23 tabeller, som byggdes upp av en\npipeline i 19 steg som gick från en tom fil till en komplett databas. Stegen följde\nen fast ordning och vart och ett var skrivet så att det kunde upprepas säkert, så att\npipelinen kunde köras mot en befintlig databas utan att någon rad dubblerades.\nFyrtioen Python-moduler på sammanlagt 10 580 rader renderade sedan sex\nutdataformat från den enda källan, med bara två beroenden vid körning. Dessa\nsiffror beskriver implementationen i det dokumenterade utvecklingsskedet.\n\nInne i ett enskilt jobb spelar hastighet lika stor roll som ordning. En\n[pipeline som aggregerar elförbrukning per timme](/sv/portfolio/a-month-of-meter-readings-in-180-milliseconds/)\ntar JSONL-data som rapporteras varje timme, var 15:e minut eller vid oregelbundna tidpunkter,\njusterar dem till strikta timintervall, summerar produktionsmixen, lägger till import och drar av\nexport och producerar en rad per timme och zon. Den byggdes på tre sätt, i Python, i JQ och i SQL på\nPostgreSQL, och varje variant benchmarkades på ett dygns och trettio dygns data. Python-varianten\nvar snabbast, med 34 ms för ett dygn och 180 ms för trettio, och koden skrevs så att den kunde\nbyggas ut till fler zoner eller integreras i en ETL-pipeline.\n\n## Var det går fel\n\n**En omkörning ger ett annat svar.** Ett dagligt jobb lägger till sina summor med `INSERT`, går\nsönder halvvägs, och schemaläggaren gör om det, så att raderna som skrevs före avbrottet nu finns\ntvå gånger. Ett jobb som väljer allt sedan aktuell tid minus ett dygn läser en annan del vid\nomförsöket än vid första försöket, och ett jobb som läser den senaste versionen av sin indata får\nmed sig det som hann ändras däremellan. Guiden Best Practices tar upp alla tre: ersätt `INSERT` med\nen upsert, läs och skriv en bestämd partition med körningens `data_interval_start` som nyckel, och\nhåll `now()` utanför varje kritisk beräkning. En enkel lösning för en sammanfattningstabell per timme i PostgreSQL är att ersätta hela intervallet i en enda transaktion.\n\n```sql\nBEGIN;\nDELETE FROM hourly_load\nWHERE hour_start \u003e= :'start' AND hour_start \u003c :'end';\nINSERT INTO hourly_load (zone, hour_start, mwh)\nSELECT zone, date_trunc('hour', read_at), sum(mwh)\nFROM reading\nWHERE read_at \u003e= :'start' AND read_at \u003c :'end'\nGROUP BY zone, date_trunc('hour', read_at);\nCOMMIT;\n```\n\nKörd som `psql -v ON_ERROR_STOP=1 -v start=... -v end=... -f hourly_load.sql`, med början och slutet\nav körningens dataintervall inskickade av orkestreraren, raderar jobbet och skriver om exakt det\nintervallets rader, så att en andra körning lämnar tabellen som den första gjorde. Formen `:'start'`\när psql-syntax för att infoga en variabel citerad som en SQL-literal.\n\n**Ett jobb blir grönt och datan är fel.** En orkestrerare ser om processen för ett jobb avslutades\nrent, och det är allt den ser. Verktyget psql är ett tydligt exempel: som standard fortsätter det\nefter ett fel i ett skript och returnerar 0 till skalet, så ett steg som kör `psql -f` rapporterar\nframgång även när en sats i det gick sönder. Med `ON_ERROR_STOP` satt stannar psql vid det första\nfelet och avslutas med slutkod 3, så att steget fallerar där det ska. En ren avslutning bevisar ändå\nbara att programmet kördes, och därför föreslår guiden självkontroller: en uppgift längre ned i\nkedjan som bekräftar att partitionen skrevs och att datan ser rimlig ut innan något läser den. För\nen körning som hänger sig i stället för att gå sönder utlöser Deadline Alerts, som kom i Airflow 3.1\noch ersätter SLA-funktionen som togs bort i 3.0, en callback, till exempel ett mejl, när en körning\npasserar en tidsgräns.\n\n**En pipeline som slås på igen startar en flod av körningar.** Med `catchup=True` skapar\nschemaläggaren en körning för varje dataintervall som den hoppade över sedan startdatumet, och\ndokumentationen för Airflow tillägger att catchup också utlöses när en Dag stängs av en tid och\nsedan aktiveras igen. En daglig pipeline som pausats i en månad kan komma tillbaka med trettio\nkörningar som väntar mot samma källa. Standardvärdet, `catchup_by_default=False`, gör att\nschemaläggaren bara skapar en körning för det senaste intervallet, och dokumentationen säger att en\nDag vars jobb läser aktuell tid i stället för sitt intervall bör ha catchup avstängt. Historik fylls\nhellre i med avsikt genom `airflow backfill create`, som tar ett datumintervall och en gräns för\nparallella körningar genom `--max-active-runs`.\n\n**Tung kod överst i en Dag-fil gör schemaläggaren långsam.** Airflow tolkar varje Dag-fil om och om\nigen, med minst `min_file_process_interval` sekunder mellan tolkningarna, så kod på översta nivån i\nfilen, utanför alla uppgifter, körs långt oftare än själva pipelinen. En databasfråga, ett\nnätverksanrop eller en långsam import där kostar tid vid varje tolkning, och guiden Best Practices\nvisar ett exempel där ett enda sådant anrop gör att en Dag tar ytterligare 1 000 sekunder att tolka.\nBegränsa översta nivån till att deklarera uppgifter och deras ordning, och flytta dyra importer och\nanrop in i de uppgiftsfunktioner som behöver dem.\n\n## Läs mer\n\n- [Apache Airflow](https://airflow.apache.org/docs/apache-airflow/stable/index.html) — projektets\n  egen översikt: arbetsflöden som Python-kod, orkestrering av batcher, backfill och omkörning av\n  enbart de misslyckade uppgifterna.\n- [Best Practices](https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html) —\n  uppgifter som behandlas som transaktioner, samma utfall vid varje omkörning, kod på översta nivån\n  och självkontroller.\n- [Dags](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/dags.html) — hur en Dag\n  deklarerar sitt schema, sina uppgifter, beroenden och standardargument som omförsök, och var\n  Deadline Alerts passar in.\n- [Dag Runs](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/dag-run.html) —\n  dataintervall, catchup, backfill och rensning av uppgifter så att de körs igen.\n- [Tasks](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/tasks.html) —\n  beroenden mellan uppgifter, tidsgränser, policyer för omförsök och övergången från SLA till\n  Deadline Alerts.\n- [psql](https://www.postgresql.org/docs/current/app-psql.html) — variabler och hur de citeras,\n  `ON_ERROR_STOP` och de slutkoder som en orkestrerare läser.\n\n\u003chttps://engineer.company/sv/glossary/pipeline/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en datapipeline ordnar, schemalägger och upprepar sina jobb, vad en orkestrerare tillför utöver en crontab och fyra sätt som en körning går fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/pipeline/index.gmi","gopher":"https://engineer.company/sv/glossary/pipeline/gophermap","html":"https://engineer.company/sv/glossary/pipeline/","json":"https://engineer.company/sv/glossary/pipeline/index.json","markdown":"https://engineer.company/sv/glossary/pipeline/index.md","pdf":"https://engineer.company/sv/glossary/pipeline/index.pdf"},"kind":"page","language":"sv","title":"Vad är en datapipeline?","url":"https://engineer.company/sv/glossary/pipeline/","version":1}