het schrijven van applicatie code dateert van voor de meeste cloud-oplossingen-oplossingen die de meeste applicatie programmeurs schrijven specifiek voor deze dagen.

om deze dissonantie aan te pakken, is de 12-Factor App methodologie ontstaan. De 12 factors is een aanpak die programmeurs helpt om moderne apps declaratief te schrijven, met behulp van duidelijke contracten die via de cloud worden geïmplementeerd.

In dit artikel zal ik de 12-factor app methodologie introduceren en een samenvatting van de principes op hoog niveau aanbieden.

Wat is de 12-Factor app-methodologie?

in 2012 debuteerden programmeurs van Heroku de 12-Factor app-methodologie. Deze programmeurs hebben ontwikkeld en geïmplementeerd honderden apps schreef deze methodologie, voortbouwend op hun ervaring van het zien van SaaS apps “in het wild”.

Deze groep beschouwt de methodologie als een triangulatie van:

• ideale praktijken om app-ontwikkeling te ondersteunen
• de dynamiek die optreedt als een app organisch groeit
• de relatie en samenwerking tussen codebase-ontwikkelaars

hun doelen zijn tweeledig:

• om software-erosiekosten te voorkomen
• om het bewustzijn te vergroten van systemische problemen die ze hebben waargenomen in de moderne app-ontwikkeling

de groep wijst op twee inspirerende bronnen, patronen van Enterprise Application Architecture en Refactoring, beide door professionele Ontwikkelaar Martin Fowler.

en nu zal ik elk van de 12 factoren introduceren.

Principe I. Codebase

“One codebase tracked in revision control, many deploys”

uw codebasis moet een logisch versiebeheersysteem hebben dat gemakkelijk te begrijpen is.

elke implementatie moet zijn eigen code repository hebben die in meerdere omgevingen kan worden geïmplementeerd. Vermijd het huisvesten van meerdere toepassingen in dezelfde repository. Dit maakt versiebeheer bijna onmogelijk te begrijpen en versies zullen verstrikt raken, wat resulteert in werk zonder toegevoegde waarde.

Principe II. afhankelijkheden

“afhankelijkheden expliciet verklaren en isoleren”

Dit principe houdt in dat u nooit moet vertrouwen op het impliciete bestaan van systeembrede pakketten. In plaats daarvan ”

• zorg ervoor dat app-specifieke bibliotheken beschikbaar zijn
• verifieer shelling naar het besturingssysteem
• Controleer of benodigde systeembibliotheken, zoals curl of ImageMagick, beschikbaar zijn. (Er is geen garantie dat deze bestaan op elk systeem waar de app zou kunnen draaien in de toekomst.)

in het algemeen moet een 12-factor app zichzelf bevatten. De toepassing moet voldoende geïsoleerd zijn om interacties met conflicterende bibliotheken die op de hostmachine zijn geïnstalleerd te voorkomen.

laten we een voorbeeld bekijken. In Python kunt u declaratie en isolatie bereiken door respectievelijk Pip en Virtualenv te gebruiken. Om aan dit principe te voldoen, moet je altijd zowel verklaring van afhankelijkheid als isolement gebruiken. Beheer afhankelijkheden binnen de toepassing, niet vanuit een externe bron. Afhankelijkheden moeten worden gehost in een repository binnen de app

Principe III. Config

“Store config in the environment”

een toepassing en de configuratie ervan moet volledig onafhankelijk zijn. Verder, het opslaan van configuraties constant in code moet volledig worden vermeden.

uw configuraties zouden een apart bestand moeten hebben en zouden niet gehost moeten worden in de code repository. Een apart configuratiebestand maakt het gemakkelijk om de configuratiewaarden bij te werken zonder de werkelijke codebasis aan te raken, waardoor de noodzaak voor herimplementatie van uw toepassingen wordt geëlimineerd wanneer u bepaalde configuratiewaarden wijzigt.

wanneer configuraties zich in de omgeving bevinden, niet in de app, Als variabelen, kunt u deze eenvoudig naar een andere omgeving verplaatsen zonder de broncode aan te raken. Twaalf-factor apps store configs als variabelen, zodat ze” onwaarschijnlijk worden gecontroleerd in de repository ” per ongeluk. Nog een bonus: dan zijn uw configuraties onafhankelijk van taal en OS.

Principe IV. Backing services

“Treat backing services as attached resources”

in een 12-factor app moeten alle services die de core app niet ondersteunen als een service worden benaderd. Deze niet-essentiële diensten kunnen zijn:

• Databases
• externe opslag
• Berichtwachtrijen
• enz.

Deze kunnen worden behandeld als een bron. Deze moeten worden benaderd als een service via HTTP of een soortgelijk verzoek, dan gespecificeerd in de configuratie. Op deze manier, bron van de dienst kan worden gewijzigd zonder dat de kerncode van de app.

bijvoorbeeld, een app die gebruik maakt van een message queuing Systeem is het beste als het gemakkelijk kan veranderen van RabbitMQ naar ZeroMQ naar ActiveMQ door alleen de configuratie-informatie te wijzigen.

Principe V. Build, release, run

“Strictly separate build and run stages”

een 12-factor app is strikt over het scheiden van de drie stadia van bouwen, vrijgeven en draaien.

Start het bouwproces door de app op te slaan in bronbeheer, en bouw vervolgens de afhankelijkheden op. Het scheiden van de config informatie betekent dat u kunt combineren met de build voor de release fase—en dan is het klaar voor de run fase. Het is ook belangrijk dat elke release een unieke ID heeft.

Principe VI. processen

“Voer de app uit als een of meer stateless processen”

slaan alle gegevens op die nodig zijn om te blijven bestaan in een stateful backing service, zoals databases. Het idee is dat het proces staatloos is en absoluut niets deelt.

hoewel veel ontwikkelaars gewend zijn aan” sticky sessions”, is het opslaan van informatie in de sessie die verwacht dat het volgende verzoek van dezelfde service afkomstig zal zijn, in tegenspraak met deze methodologie.

Principe VII. Port binding Principe

“Export services via port binding”

12-factor apps moeten altijd onafhankelijk zijn van aanvullende toepassingen. Elke functie moet zijn eigen proces zijn-in volledige isolatie.

in een traditionele omgeving gaan we ervan uit dat verschillende processen verschillende functionaliteiten verwerken. Als zodanig, is het gemakkelijk om verder aan te nemen dat deze functionaliteiten beschikbaar zijn via een web protocol, zoals HTTP, waardoor het waarschijnlijk is dat apps zullen draaien achter webservers, zoals Apache of Tomcat. Maar dit is in strijd met de 12-factor methodologie.

voeg in plaats daarvan een webserverbibliotheek of iets dergelijks toe aan de core-app. Dit betekent dat de app aanvragen kan wachten op een gedefinieerde poort, of dat HTTP of een ander protocol.

beginsel VIII. Concurrency

“Scale out via the process model”

een echte 12-factor app is ontworpen voor schalen. Bouw uw applicaties zodat schalen in de cloud naadloos verloopt. Wanneer u de app te ontwikkelen om gelijktijdig te zijn, u kunt draaien nieuwe exemplaren naar de cloud moeiteloos.

om meer capaciteit toe te voegen (start extra processen op extra machines), moet uw app in staat zijn om meer instanties toe te voegen in plaats van meer geheugen of CPU op de lokale machine.

beginsel IX. Disposability

“Maximaliseer robuustheid met snel opstarten en gracieuze shutdown”

het concept van wegwerpprocessen betekent dat een applicatie op elk moment kan sterven, maar het heeft geen invloed op de gebruiker—de app kan worden vervangen door andere apps, of het kan meteen opnieuw beginnen. Het bouwen van disposability in uw app zorgt ervoor dat de app sluit sierlijk: het moet opruimen van alle gebruikte middelen en stilgelegd soepel.

als deze manier is ontworpen, komt de app snel weer omhoog. Evenzo, wanneer processen beëindigen, ze moeten hun huidige verzoek te voltooien, weigeren een inkomend verzoek, en afsluiten.

Principe X. dev/prod pariteit

“houd ontwikkeling, staging, en productie zo vergelijkbaar mogelijk”

toepassingen die worden ingezet voor ontwikkeling en productie moeten pariteit hebben. In wezen zou er slechts het geringste verschil moeten zijn tussen beide implementaties.

een groot verschil kan leiden tot onbedoelde compatibiliteitsproblemen tussen dev en productiecode. Bij het bouwen van een 12-factor app, backing services tussen dev en prod moet hetzelfde zijn; een verschil hier kan leiden tot aanzienlijke problemen in de toekomst.XI. Logs

“Treat logs as event streams”

In tegenstelling tot monolithische en traditionele apps die loginformatie opslaan in een bestand, houdt dit principe in dat u logs moet streamen naar een gekozen locatie—niet gewoon dump ze in een logbestand.

logs bevinden zich meestal niet op dezelfde plaats in cloudgebaseerde omgevingen na elke brand. Als nieuwe processen starten of uw app crasht, zullen de logs worden verspreid over verschillende cloud machines; ze zullen niet zitten op een enkele machine of host.

los dit probleem op door een gemeenschappelijke plaats te noemen voor de logs die moeten worden gestreamd. In sommige gevallen kunt u Stdout gewoon omleiden naar een bestand. Waarschijnlijker is echter dat u een log router zoals Fluentd wilt implementeren en de logs wilt opslaan in Hadoop of een specifieke service, zoals Splunk.

Principe XII. beheerprocessen

“Beheer/beheertaken uitvoeren als eenmalige processen”

Het Laatste 12-factor app-principe stelt voor beheertaken te scheiden van de rest van uw toepassing. Deze taken kunnen het migreren van een database of het inspecteren van records omvatten.

hoewel de beheerprocessen gescheiden zijn, moet u ze blijven uitvoeren in dezelfde omgeving en tegen de basiscode en configuratie van de app zelf. Verzending van de admin taken code naast de toepassing voorkomt drift.

gerelateerd lezen

• BMC DevOps Blog
• Agile vs Waterfall SDLCs: Wat is het verschil?
• Deployment Pipelines (CI/CD) in Software Engineering
• Wat Is Extreme Programming (XP)?
• Hoe & waarom een softwarefabriek worden
• topconferenties voor programmeren & softwareontwikkeling