skriva applikationskod föregår de flesta molnlösningar-lösningar som de flesta applikationsprogrammerare skriver specifikt för dessa dagar.

för att hantera denna dissonans har 12-Faktorappmetoden uppstått. De 12 faktorerna är ett tillvägagångssätt som hjälper programmerare att skriva moderna appar på ett deklarativt sätt med hjälp av tydliga kontrakt som distribueras via molnet.

i den här artikeln presenterar jag 12-faktorappmetoden och erbjuder en sammanfattning av dess principer på hög nivå.

Vad är 12-faktor app metodik?

under 2012 debuterade programmerare på Heroku 12-faktor app-metoden. Dessa programmerare har utvecklat och distribuerat hundratals appar skrev denna metod, som bygger på deras erfarenhet av att se SaaS-appar ”i naturen”.

denna grupp anser att metodiken är en triangulering av:

• idealiska metoder för att stödja apputveckling
• dynamiken som uppstår när en app växer organiskt
• förhållandet och samarbetet mellan kodbasutvecklare

deras mål är tvåfaldiga:

• för att undvika erosionskostnader för programvara
• för att öka medvetenheten om systemproblem som de har observerat i modern apputveckling

gruppen pekar på två inspirerande källor, mönster för Företagsapplikationsarkitektur och Refactoring, båda av professionell Utvecklare Martin Fowler.

och nu ska jag presentera var och en av de 12 faktorerna.

princip I. kodbas

”en kodbas som spåras i revisionskontroll, många distribuerar”

din kodbas ska ha ett logiskt versionskontrollsystem som är lätt att förstå.

varje distribution ska ha sitt eget kodförråd som kan distribueras till flera miljöer. Undvik att placera flera applikationer i samma arkiv. Detta gör versionskontroll nästan omöjligt att förstå och versioner kommer att trassla in sig, vilket resulterar i icke-mervärde arbete.

princip II. beroenden

”explicit deklarera och isolera beroenden”

denna princip hävdar att du aldrig ska lita på den implicita existensen av systemomfattande paket. Istället ”

• se till att appspecifika bibliotek är tillgängliga
• verifiera beskjutning till operativsystemet
• kontrollera att nödvändiga systembibliotek, som curl eller ImageMagick, är tillgängliga. (Det finns ingen garanti för att dessa finns på alla system där appen kan köras i framtiden.)

sammantaget måste en 12-faktor app vara självinnehållande. Applikationen bör isoleras tillräckligt för att undvika interaktioner med motstridiga bibliotek som är installerade på värddatorn.

låt oss titta på ett exempel. I Python kan du uppnå deklaration och isolering genom att använda Pip respektive Virtualenv. För att uppfylla denna princip måste du alltid använda både deklaration om beroende och isolering. Hantera beroenden i programmet, inte från en extern källa. Beroenden bör vara värd i ett arkiv i appen

princip III. Config

”Store config i miljön”

ett program och dess konfiguration bör vara helt oberoende. Vidare bör lagring av configs ständigt i kod undvikas helt.

dina konfigurationer ska ha en separat fil och bör inte vara värd i kodförvaret. En separat konfigurationsfil gör det enkelt att uppdatera konfigurationsvärdena utan att röra den faktiska kodbasen, vilket eliminerar behovet av omdistribution av dina program när du ändrar vissa konfigurationsvärden.

När konfigurationer är i miljön, inte appen, som variabler, kan du enkelt flytta den till en annan miljö utan att röra källkoden. Tolvfaktorsappar lagrar konfigureringar som variabler så att de ”sannolikt inte kommer att kontrolleras i förvaret” av misstag. En annan bonus: då är dina configs oberoende av språk och operativsystem.

princip IV. stödtjänster

”behandla stödtjänster som bifogade resurser”

i en 12-faktorsapp måste alla tjänster som inte stöder kärnappen nås som en tjänst. Dessa icke-centrala väsentliga tjänster kan inkludera:

• databaser
• extern lagring
• meddelandeköer
• etc.

dessa kan behandlas som en resurs. Dessa bör nås som en tjänst via HTTP eller liknande begäran, sedan anges i config. På så sätt kan tjänstens källa ändras utan att påverka appens kärnkod.

till exempel är en app som använder ett meddelandekösystem bäst om det enkelt kan ändras från RabbitMQ till ZeroMQ till ActiveMQ genom att bara ändra konfigurationsinformation.

princip V. Bygg, släpp, kör

”strikt separata Bygg-och körsteg”

en 12-faktor app är strikt om att separera de tre stegen att bygga, släppa och springa.

starta byggprocessen genom att lagra appen i källkontroll och bygg sedan ut dess beroenden. Att separera konfigurationsinformationen innebär att du kan kombinera den med build för release—scenen-och sedan är den redo för run-scenen. Det är också viktigt att varje utgåva har ett unikt ID.

princip VI. processer

”Kör appen som en eller flera statslösa processer”

lagra alla data som krävs för att kvarstå i en statlig stödtjänst, till exempel databaser. Tanken är att processen är statslös och delar absolut ingenting.

medan många utvecklare är vana vid ”klibbiga sessioner”, lagrar information i sessionen som förväntar sig att nästa begäran kommer från samma tjänst motsäger denna metod.

Princip VII. Portbindningsprincip

”exporttjänster via portbindning”

12-faktorsappar måste alltid vara oberoende av ytterligare applikationer. Varje funktion ska vara sin egen process-i full isolering.

i en traditionell miljö antar vi att olika processer hanterar olika funktioner. Som sådan är det lätt att vidare anta att dessa funktioner är tillgängliga via ett webbprotokoll, till exempel HTTP, vilket gör det troligt att appar kommer att köras bakom webbservrar, som Apache eller Tomcat. Men detta strider mot 12-faktorsmetoden.

lägg istället till ett webbserverbibliotek eller liknande till core-appen. Detta innebär att appen kan vänta förfrågningar på en definierad port, oavsett om det är HTTP eller ett annat protokoll.

princip VIII. samtidighet

”skala ut via processmodellen”

en sann 12-faktor app är utformad för skalning. Bygg dina applikationer så att skalning i molnet är sömlös. När du utvecklar appen för att vara samtidig kan du snurra upp nya instanser till molnet utan problem.

för att lägga till mer kapacitet (starta ytterligare processer på ytterligare maskiner) bör din app kunna lägga till fler instanser istället för mer minne eller CPU på den lokala datorn.

princip IX. Disposability

”maximera robusthet med snabb start och graciös avstängning”

begreppet disponibla processer innebär att ett program kan dö när som helst, men det kommer inte att påverka användaren—appen kan ersättas av andra program, eller det kan starta upp igen. Att bygga disponibilitet i din app säkerställer att appen stängs graciöst: den ska städa upp alla använda resurser och stängas av smidigt.

När den är utformad på detta sätt kommer appen snabbt upp igen. På samma sätt, när processer avslutas, bör de avsluta sin nuvarande begäran, vägra inkommande begäran och avsluta.

princip X. dev / prod parity

”Håll utveckling, iscensättning och produktion så lika som möjligt”

applikationer som distribueras till utveckling och produktion bör ha paritet. I huvudsak bör det bara finnas den minsta skillnaden mellan båda distributionerna.

en stor skillnad kan leda till oavsiktliga kompatibilitetsproblem mellan dev och produktionskod. När du bygger en 12-faktor app, stödtjänster mellan dev och prod måste vara samma; en skillnad här kan orsaka betydande problem längs linjen.

princip XI. Logs

”behandla loggar som händelseströmmar”

Till skillnad från monolitiska och traditionella program som lagrar logginformation i en fil, hävdar denna princip att du bör strömma loggar till en vald plats—inte bara dumpa dem i en loggfil.

vanligtvis finns loggar inte på samma plats i molnbaserade miljöer efter varje brännskada. När nya processer startar eller din app kraschar kommer loggarna att distribueras över flera molnmaskiner; de sitter inte på en enda maskin eller värd.

Lös problemet genom att namnge en gemensam plats för loggarna att strömma. I vissa fall kan du helt enkelt omdirigera Stdout till en fil. Mer sannolikt vill du dock distribuera en loggrouter som Fluentd och spara loggarna till Hadoop eller en specifik tjänst, som Splunk.

princip XII. Admin processer

”kör admin/hanteringsuppgifter som engångs processer”

den slutliga 12-faktor app princip föreslår separera administrativa uppgifter från resten av din ansökan. Dessa uppgifter kan inkludera migrering av en databas eller inspektion av poster.

även om administratörsprocesserna är separata måste du fortsätta att köra dem i samma miljö och mot baskoden och konfigurationen för själva appen. Shipping admin uppgifter koden tillsammans med programmet förhindrar drift.

relaterad läsning

• BMC DevOps Blog
• Agile vs vattenfall SDLCs: Vad är skillnaden?
• Deployment Pipelines (CI/CD) i programvaruteknik
• Vad är Extreme Programming (XP)?
• hur& Varför bli en Mjukvarufabrik
• toppkonferenser för programmering & mjukvaruutveckling