{"canonical_url":"https://engineer.company/sv/glossary/microservices/","content_markdown":"# Mikrotjänster\n\n## Vad det är\n\nMikrotjänster är en arkitekturstil som delar upp en applikation i små tjänster.\nVarje tjänst är ett fristående program som körs som en egen process och kan\ndriftsättas utan de andra. James Lewis och Martin Fowler, vars artikel från 2014\ngav stilen dess mest kända beskrivning, kallar sådana applikationer ”suites of\nindependently deployable services”. De räknar upp vad sådana system brukar ha\ngemensamt: tjänsterna pratar med varandra över lätta mekanismer, ofta ett\nHTTP-API för resurser; de byggs kring affärsförmågor; driftsättningen är helt\nautomatiserad; den centrala styrningen hålls till ett minimum, och tjänsterna\nfår skrivas i olika programspråk och använda olika tekniker för datalagring. De\npåpekar själva att det inte finns någon formell definition, bara kännetecken som\nde flesta system med den etiketten delar.\n\nOrdet är yngre än idén. En fotnot i samma artikel berättar att en workshop med\nmjukvaruarkitekter nära Venedig diskuterade begreppet i maj 2011, och att samma\ngrupp i maj 2012 bestämde sig för ”microservices” som namn. Adrian Cockcroft på\nNetflix kallade angreppssättet ”fine grained SOA”, och Lewis och Fowler hävdar\ninte att stilen är ny: de hittar rötterna åtminstone så långt tillbaka som\nprinciperna Unix byggdes på.\n\nDet stilen oftast jämförs med är monoliten: en applikation på serversidan som\nbyggs och driftsätts som en enda enhet. All logik för en förfrågan körs i en och\nsamma process. Med lite omsorg kan hela applikationen köras och testas på en\nenskild utvecklares bärbara dator, och den skalas genom att fler kopior körs\nbakom en lastbalanserare. Friktionen kommer senare. En liten ändring innebär att\nallt måste byggas och driftsättas på nytt, en god modulär struktur är svår att\nbevara år efter år, och den del som behöver mer kapacitet kan bara skalas\ntillsammans med allt annat.\n\nLewis och Fowler definierar en komponent som en enhet av programvara som kan\nbytas ut och uppgraderas för sig. Ett bibliotek länkas in i ett program och\nanropas i minnet. En tjänst är en komponent utanför processen, som nås över\nnätverket med en webbförfrågan eller ett fjärranrop. Skillnaden spelar roll för\nkopplingen. I de flesta språk är det bara dokumentation och disciplin som\nhindrar annan kod från att peta i bibliotekets inre, medan en tjänst bara kan\nnås genom uttryckliga fjärranrop, så gränssnittet är betydligt svårare att gå\nrunt. En tjänst kan ändå bestå av flera processer, till exempel en applikation\ntillsammans med en databas som bara den använder.\n\nFörledet ”mikro” säger mindre än det verkar. Lewis och Fowler påpekar att namnet\nriktar uppmärksamheten mot storlek och leder till diskussioner om vad som räknas\nsom ”mikro”. De största tjänsterna de hade hört talas om följde Amazons idé om\nett team som två pizzor räcker till, alltså högst ett dussin personer, och i\nandra änden av skalan såg de ett team på ett halvdussin som tog hand om ett\nhalvdussin tjänster.\n\n## Varför det spelar roll\n\nDen första vinsten är att varje tjänst kan släppas i sin egen takt. När en\napplikation är uppdelad i tjänster kräver många ändringar bara att en tjänst\ndriftsätts på nytt, så ett team kan leverera utan att vänta på de andra. Lewis\noch Fowler är tydliga med att det inte gäller fullt ut: en ändring i en tjänsts\ngränssnitt måste fortfarande samordnas med de tjänster som anropar den.\n\nDen andra är att mjukvaran kan följa organisationen i stället för att kämpa emot\nden. År 1968 hävdade Melvin Conway i Datamation att organisationer som\nkonstruerar system är tvungna att ta fram konstruktioner som efterliknar deras\negna kommunikationsstrukturer. Lewis och Fowler tillämpar det på det vanliga\nsättet att dela upp en stor applikation, efter tekniska skikt, med ett team för\nUI:t, ett för logiken på serversidan och ett för databasen. Då blir även en\nenkel ändring ett projekt över teamgränserna, och logiken hamnar där något team\nråkar ha åtkomst. Mikrotjänststilen vänder på det. Varje tjänst täcker en\naffärsförmåga, som order, lager eller betalning, från skärmen ända ned till\nlagringen, och tillhör ett tvärfunktionellt team som har alla kompetenser som\nbehövs hela vägen ned. Teamet bör äga tjänsten under hela dess livstid i stället\nför att lämna över den när ett projekt är slut, och Amazons version av regeln är\natt den som bygger en tjänst också kör den i produktion.\n\nDen tredje är att logiken stannar i tjänsterna. Lewis och Fowler sammanfattar\nhållningen som smart endpoints and dumb pipes: smarta ändpunkter och enkla rör\nemellan. Tjänsterna kommunicerar med HTTP-förfrågningar mot resurs-API:er, eller\nvia en lätt meddelandebuss som inte gör något annat än att routa meddelanden,\noch besluten fattas i tjänsterna i vardera änden. Det är ett medvetet steg bort\nfrån en enterprise service bus, som routar, transformerar och tillämpar\naffärsregler mitt i nätverket i stället för i dess ändar.\n\nData delas upp längs samma linjer. Varje tjänst sköter sin egen databas, och\nolika tjänster kan använda olika databassystem om det passar deras arbete. Eric\nEvans domändrivna design står för motiveringen: ett stort system rymmer flera\nmodeller, och var och en behöver en uttryckligt avgränsad kontext (bounded\ncontext), bestämd utifrån hur teamen är organiserade, vilka delar av\napplikationen modellen gäller för och fysiska saker som kodbaser och\ndatabasscheman. Säljavdelningens bild av en kund och kundtjänstens bild av samma\nkund kan då skilja sig åt, utan att någon behöver jämka ihop dem i en tabell.\n\nKostnaderna hör till definitionen, och Lewis och Fowler säger dem rakt ut. Ett\nfjärranrop kostar mycket mer än ett anrop i minnet, så gränssnitten mellan\ntjänster måste bli grövre. Det är besvärligt att flytta kod över en\ntjänstegräns: ändringar i gränssnitt måste samordnas, skikt för\nbakåtkompatibilitet måste läggas till och testningen blir krångligare.\nDistribuerade transaktioner är svåra att implementera, så tjänsterna samordnar\nsig utan dem, godtar att data kanske blir konsistenta först efter en stund och\nrättar till fel med kompenserande operationer. Vilket anrop som helst kan\nmisslyckas. Och om tjänsterna inte passar ihop snyggt har komplexiteten inte\nförsvunnit; den har bara flyttat ut i kopplingarna mellan dem, där den är\nsvårare att se. Lewis och Fowler återger ett argument som de tycker är rimligt:\nbygg en monolit till att börja med, ge den rena moduler och dela upp den först\nnär den börjar ställa till problem. De lägger till ett förbehåll: ett gränssnitt\nsom fungerar bra inom en process blir sällan ett bra gränssnitt mellan tjänster.\n\n## Så ser det ut i praktiken\n\nAnteckningen\n[Att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\ntar till en egen tjänst först när en databas inte längre räcker, och formulerar\ndå regeln som håller ihop designen: varje vara ska ha en enda ägare av sitt\nlagersaldo, lagertjänsten, och ingen annan får fatta beslut om det. Tjänsten\nshardas på tenant och vara, och de största tenanterna får egna celler. Bara\nreservationen behöver vara synkron. Betalningen, ordern och kvittot är separata\nsystem, och ingen gemensam transaktion omfattar dem. Anteckningen avvisar\ntvåfas-commit, eftersom den blockerar så länge någon deltagare är långsam och\nbetalningsleverantörer inte deltar i den, och använder i stället en saga: en\nföljd av lokala steg, vart och ett med ett eget steg som ångrar det.\n\nVarje steg lägger sitt meddelande i en outbox-tabell, inom samma transaktion som\nden ändring meddelandet berättar om. I PostgreSQL kan en datamodifierande sats\ninuti `WITH` skicka sitt resultat vidare till en insättning, så lagertjänsten\nkan reservera en enhet och registrera meddelandet i en och samma sats:\n\n```sql\n-- lagertjänsten, med en egen databas\nWITH held AS (\n    UPDATE inventory\n    SET available = available - 1\n    WHERE tenant_id = 't-7' AND item_id = 'item-881'\n      AND available \u003e= 1\n    RETURNING item_id\n)\nINSERT INTO outbox (order_id, item_id, event, units)\nSELECT 'A-17', item_id, 'StockReserved', 1 FROM held;\n-- slutsålt: ingen rad matchar, så inget meddelande skrivs\n```\n\nChange data capture publicerar sedan raderna i outbox-tabellen. Eftersom ett\nmeddelande kan levereras mer än en gång måste varje mottagare vara idempotent,\nmed ordern som nyckel. I den här skissen rör ingen annan tjänst tabellen\n`inventory`: de andra får veta hur det står till med lagret genom de här\nmeddelandena, eller genom att fråga lagertjänsten.\n\nSamma anteckning visar också var uppdelningen hör hemma i arbetsordningen. I\nlistan över vad som ska göras först kommer en egen tjänst och en egen ägare för\nlagret på fjärde plats: efter mätningen, efter att skrivningen har gjorts om\ntill en enda villkorad sats och efter att lasten har minskats med ett väntrum,\nen spärr och ett cachat ”slutsålt”-svar. De billigare åtgärderna kommer först.\n\nPortföljfallet [En sjöfartsplattform byggd i rena\nskikt](/sv/portfolio/a-maritime-platform-built-in-clean-layers/) dokumenterar\ngrundarens arkitekturbidrag till NextMariner och visar den andra sidan av valet.\nDet var en ung produkt där kraven skulle komma att ändras en hel del, och målet\nvar att en ändrad affärsregel inte skulle innebära att frontenden, API:et och\ndatabasen måste röras på en gång. Lösningen blev tre skikt med ett jobb var: en\nNext.js-frontend för presentationen, ett medvetet tunt Go-API som routar,\nvaliderar, filtrerar för säkerhet och orkestrerar, och all affärslogik i\nPostgreSQL-funktioner. Gränserna dokumenterades och upprätthölls i granskningen.\nLewis och Fowler konstaterar att modulära gränser inom en applikation kräver\nmycket disciplin för att hålla, och att den tydligare uppdelningen i tjänster\ngör det lättare att hålla teamgränserna klara. Den här plattformen höll\ndisciplinen utan att dela upp sin affärslogik i separata tjänster.\n\n## Var det går fel\n\n**Kedjor av synkrona anrop multiplicerar driftstopp.** När svaret på en\nförfrågan kräver att den första tjänsten anropar en andra, som anropar en\ntredje, lyckas förfrågan bara så länge alla tre är uppe, och den väntar på var\noch en av dem i tur och ordning. Lewis och Fowler kallar det den multiplikativa\neffekten av driftstopp och hänvisar till Guardians regel om ett synkront anrop\nper användarförfrågan. Håll den synkrona vägen lika kort som anteckningen håller\nden, där bara reservationen väntar på svar och allt efter den är meddelanden. Ge\nvarje anrop som återstår en timeout och en circuit breaker, de mönster Lewis och\nFowler hänvisar till i boken Release It!, så att en tjänst som fallerar kopplas\nbort i stället för att bli väntad på.\n\n**Tjänster som alltid ändras tillsammans.** En uppdelning längs fel linjer ger\ntjänster som inte kan släppas var för sig: varje ny funktion berör tre av dem,\noch de levereras i takt. Lewis och Fowler ger testet: om du gång på gång ändrar\ntvå tjänster samtidigt bör de slås ihop. Ett närliggande misstag är att göra om\nmetodanrop till fjärranrop ett till ett, så att tjänsterna pratar fram och\ntillbaka över nätverket och presterar dåligt. Dra gränserna kring affärsförmågor\noch avgränsade kontexter, gör gränssnitten grova och bygg varje tjänst så att\nden tål ändringar i de tjänster den anropar. Då kan en leverantör utvecklas utan\natt ställa till det för sina konsumenter, och versionshantering ser Lewis och\nFowler som en sista utväg.\n\n**Två tjänster delar en databas.** När ordertjänsten läser och skriver\nlagertabellerna direkt blir schemat ett gränssnitt som ingen äger: inget av\nteamen kan ändra det på egen hand, och lagersaldot får ännu en skribent, en som\nlagertjänstens kontroller aldrig ser. Ge all data en ägare, så som anteckningen\nger lagersaldot en, och låt andra tjänster fråga ägaren eller läsa dess\nmeddelanden. När en uppdatering sträcker sig över flera tjänster, använd en saga\nmed kompenserande steg i stället för en distribuerad transaktion.\n\n**Ingen kan följa en förfrågan.** En förfrågan som passerar flera tjänster\nlämnar en bit av sin historia i loggarna hos var och en av dem. Lewis och Fowler\nger övervakning i realtid en central plats, där tekniska mått som förfrågningar\nper sekund mot databasen följs sida vid sida med affärsmått som order per minut.\nDe varnar också för att tjänster som reagerar på varandras händelser ger ett\nemergent beteende som övervakningen snabbt måste fånga upp. Spåra varje\nförfrågan. I den modell OpenTelemetry använder är ett spår den väg en förfrågan\ntar genom systemet, uppbyggt av span som delar ett spår-ID och pekar på sin\nförälder, och kontextpropagering är det som gör att span från olika tjänster kan\nfogas ihop till ett spår. Skicka spårkontexten vidare med varje anrop och varje\nmeddelande, även dem som går via outbox-tabellen, annars tar spåret slut vid det\nförsta asynkrona hoppet.\n\n## Läs mer\n\n- [Microservices](https://martinfowler.com/articles/microservices.html)\n  — James Lewis och Martin Fowler, 2014: de nio kännetecknen, historien bakom\n  namnet, faktarutorna om storlek och synkrona anrop och skälen att gå\n  försiktigt fram.\n- [How Do Committees Invent?](https://www.melconway.com/Home/Committees_Paper.html)\n  — Melvin Conways artikel i Datamation från 1968, där ett systems struktur\n  efterliknar kommunikationsstrukturen i organisationen som konstruerade det.\n- [Domain-Driven Design Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)\n  — Eric Evans sammanfattning av mönstren, bland dem avgränsad kontext och\n  kartorna över hur kontexter hänger ihop.\n- [OpenTelemetry: Traces](https://opentelemetry.io/docs/concepts/signals/traces/)\n  — span, spår-ID, föräldraspan och kontextpropagering, delarna som gör en\n  förfrågan synlig över tjänstegränserna.\n- [PostgreSQL: WITH Queries](https://www.postgresql.org/docs/current/queries-with.html)\n  — datamodifierande satser i `WITH`, som låter en sats ändra en rad och\n  registrera ändringen någon annanstans.\n\n\u003chttps://engineer.company/sv/glossary/microservices/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hur en mikrotjänstarkitektur delar upp en applikation i små tjänster som driftsätts var för sig, vad det ger och var det går fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/microservices/index.gmi","gopher":"https://engineer.company/sv/glossary/microservices/gophermap","html":"https://engineer.company/sv/glossary/microservices/","json":"https://engineer.company/sv/glossary/microservices/index.json","markdown":"https://engineer.company/sv/glossary/microservices/index.md","pdf":"https://engineer.company/sv/glossary/microservices/index.pdf"},"kind":"page","language":"sv","title":"Vad är mikrotjänster?","url":"https://engineer.company/sv/glossary/microservices/","version":1}