Writing application code precede la maggior parte delle soluzioni cloud-soluzioni che la maggior parte dei programmatori di applicazioni scrivono specificamente per questi giorni.

Per gestire questa dissonanza, è emersa la metodologia dell’app a 12 fattori. I fattori 12 sono un approccio che aiuta i programmatori a scrivere app moderne in modo dichiarativo, utilizzando contratti chiari distribuiti tramite cloud.

In questo articolo, introdurrò la metodologia dell’app a 12 fattori e offrirò un riepilogo di alto livello dei suoi principi.

Qual è la metodologia dell’app a 12 fattori?

Nel 2012, i programmatori di Heroku hanno debuttato la metodologia dell’app a 12 fattori. Questi programmatori hanno sviluppato e distribuito centinaia di applicazioni ha scritto questa metodologia, attingendo alla loro esperienza di vedere le applicazioni SaaS “in natura”.

Questo gruppo considera la metodologia una triangolazione di:

• Pratiche ideali per supportare lo sviluppo di app
• Le dinamiche che si verificano quando un’app cresce organicamente
• La relazione e la collaborazione tra sviluppatori di codebase

I loro obiettivi sono duplice:

• Per evitare i costi di erosione del software
• Per aumentare la consapevolezza dei problemi sistemici che hanno osservato nello sviluppo di app moderne

Il gruppo punta a due fonti di ispirazione, Patterns of Enterprise Application Architecture e Refactoring, entrambi dallo sviluppatore professionista Martin Fowler.

E ora, introdurrò ciascuno dei 12 fattori.

Principio I. Codebase

“Una base di codice tracciata nel controllo di revisione, molte distribuzioni”

La tua base di codice dovrebbe avere un sistema di controllo della versione logico facile da capire.

Ogni distribuzione deve avere il proprio repository di codice che può essere distribuito in più ambienti. Evitare di ospitare più applicazioni nello stesso repository. Ciò rende il controllo della versione quasi impossibile da capire e le versioni si aggrovigliano, con conseguente lavoro non a valore aggiunto.

Principio II. Dipendenze

“Dichiarare e isolare esplicitamente le dipendenze”

Questo principio sostiene che non si dovrebbe mai fare affidamento sull’esistenza implicita di pacchetti a livello di sistema. Invece ”

• Assicurati che le librerie specifiche dell’app siano disponibili
• Verifica sborsando al sistema operativo
• Verifica che le librerie di sistema necessarie, come curl o ImageMagick, siano disponibili. (Non c’è alcuna garanzia che questi esistano su tutti i sistemi in cui l’app potrebbe essere eseguita in futuro.)

Nel complesso, un’app a 12 fattori deve essere auto-contenente. L’applicazione deve essere sufficientemente isolata per evitare interazioni con librerie in conflitto installate sulla macchina host.

Diamo un’occhiata ad un esempio. In Python, è possibile ottenere la dichiarazione e l’isolamento utilizzando rispettivamente Pip e Virtualenv. Per soddisfare questo principio, devi sempre usare sia la dichiarazione di dipendenza che l’isolamento. Gestire le dipendenze all’interno dell’applicazione, non da un’origine esterna. Le dipendenze dovrebbero essere ospitate in un repository all’interno dell’app

Principio III. Config

“Memorizza la configurazione nell’ambiente”

Un’applicazione e la sua configurazione dovrebbero essere completamente indipendenti. Inoltre, la memorizzazione di configurazioni costantemente nel codice dovrebbe essere evitata del tutto.

Le tue configurazioni dovrebbero avere un file separato e non dovrebbero essere ospitate all’interno del repository di codice. Un file di configurazione separato semplifica l’aggiornamento dei valori di configurazione senza toccare la base di codice effettiva, eliminando la necessità di una nuova distribuzione delle applicazioni quando si modificano determinati valori di configurazione.

Quando le configurazioni sono nell’ambiente, non nell’app, come variabili, puoi facilmente spostarlo in un altro ambiente senza toccare il codice sorgente. Le app a dodici fattori memorizzano le configurazioni come variabili in modo che siano” improbabili da controllare accidentalmente nel repository”. Un altro bonus: quindi le tue configurazioni sono indipendenti dalla lingua e dal sistema operativo.

Principio IV. Servizi di supporto

“Tratta i servizi di supporto come risorse associate”

In un’app a 12 fattori, tutti i servizi che non supportano l’app principale devono essere accessibili come servizio. Questi servizi essenziali non-core potrebbero includere:

• Database
• Archiviazione esterna
• Code di messaggi
• ecc.

Questi possono essere trattati come una risorsa. Questi dovrebbero essere accessibili come servizio tramite HTTP o richiesta simile, quindi specificati nella configurazione. In questo modo, l’origine del servizio può essere modificata senza influire sul codice principale dell’app.

Ad esempio, un’app che utilizza un sistema di accodamento dei messaggi è preferibile se può facilmente passare da RabbitMQ a ZeroMQ a ActiveMQ modificando solo le informazioni di configurazione.

Principio V. Build, release, run

“Strictly separate build and run stages”

Un’app a 12 fattori è rigorosa sulla separazione delle tre fasi di costruzione, rilascio e esecuzione.

Avvia il processo di compilazione memorizzando l’app nel controllo del codice sorgente, quindi crea le sue dipendenze. Separare le informazioni di configurazione significa che è possibile combinarle con la build per la fase di rilascio, quindi è pronta per la fase di esecuzione. È anche importante che ogni versione abbia un ID univoco.

Principio VI. Processes

“Esegui l’app come uno o più processi stateless”

Memorizza tutti i dati necessari per persistere in un servizio di supporto stateful, come i database. L’idea è che il processo sia apolide e non condivida assolutamente nulla.

Mentre molti sviluppatori sono abituati a “sessioni appiccicose”, la memorizzazione delle informazioni nella sessione in attesa che la richiesta successiva provenga dallo stesso servizio contraddice questa metodologia.

Principio VII. Port binding Principio

“Servizi di esportazione tramite port binding”

Le app a 12 fattori devono essere sempre indipendenti dalle applicazioni aggiuntive. Ogni funzione dovrebbe essere il proprio processo – in pieno isolamento.

In un ambiente tradizionale, assumiamo che diversi processi gestiscano funzionalità diverse. In quanto tale, è facile supporre ulteriormente che queste funzionalità siano disponibili tramite un protocollo Web, come HTTP, rendendo probabile che le app vengano eseguite dietro server Web, come Apache o Tomcat. Ma questo è in contrasto con la metodologia a 12 fattori.

Invece, aggiungi una libreria di server Web o simile all’app principale. Ciò significa che l’app può attendere le richieste su una porta definita, che si tratti di HTTP o di un protocollo diverso.

Principio VIII. Concorrenza

“Scalabilità tramite il modello di processo”

Una vera app a 12 fattori è progettata per il ridimensionamento. Crea le tue applicazioni in modo che il ridimensionamento nel cloud sia senza interruzioni. Quando si sviluppa l’applicazione per essere simultaneo, è possibile spin up nuove istanze al cloud senza sforzo.

Per aggiungere più capacità (avviare processi aggiuntivi su macchine aggiuntive), l’app dovrebbe essere in grado di aggiungere più istanze anziché più memoria o CPU sulla macchina locale.

Principio IX. Disposability

”Massimizza la robustezza con l’avvio rapido e l’arresto grazioso ”

Il concetto di processi usa e getta significa che un’applicazione può morire in qualsiasi momento, ma non influenzerà l’utente: l’app può essere sostituita da altre app o può ricominciare da capo. Costruire la disponibilità nella tua app assicura che l’app si spenga con garbo: dovrebbe ripulire tutte le risorse utilizzate e spegnersi senza intoppi.

Quando progettato in questo modo, l’applicazione viene di nuovo rapidamente. Allo stesso modo, quando i processi terminano, dovrebbero terminare la loro richiesta corrente, rifiutare qualsiasi richiesta in arrivo ed uscire.

Principio X. Dev/prod parity

“Mantieni sviluppo, staging e produzione il più simile possibile”

Le applicazioni distribuite allo sviluppo e alla produzione dovrebbero avere parità. In sostanza, ci dovrebbe essere solo la minima differenza tra entrambe le distribuzioni.

Una grande differenza può portare a problemi di compatibilità non intenzionali tra dev e codice di produzione. Quando si crea un’app a 12 fattori, i servizi di supporto tra dev e prod devono essere gli stessi; una differenza qui potrebbe causare problemi significativi su tutta la linea.

Principio XI. Logs

“Tratta i log come flussi di eventi”

A differenza delle app monolitiche e tradizionali che memorizzano le informazioni di log in un file, questo principio sostiene che è necessario eseguire lo streaming dei log in una posizione scelta, non semplicemente scaricarli in un file di log.

In genere, i registri non risiedono nello stesso posto all’interno di ambienti basati su cloud dopo ogni masterizzazione. Con l’avvio di nuovi processi o l’arresto anomalo dell’app, i registri verranno distribuiti su più computer cloud; non si posizioneranno su una singola macchina o host.

Risolvi questo problema nominando un luogo comune per lo streaming dei log. In alcuni casi, puoi semplicemente reindirizzare Stdout a un file. Più probabilmente, tuttavia, ti consigliamo di distribuire un router di log come Fluentd e salvare i registri su Hadoop o su un servizio specifico, come Splunk.

Principio XII. Processi di amministrazione

“Esegui attività di amministrazione/gestione come processi una tantum”

Il principio finale dell’app a 12 fattori propone di separare le attività amministrative dal resto dell’applicazione. Queste attività potrebbero includere la migrazione di un database o l’ispezione dei record.

Sebbene i processi di amministrazione siano separati, è necessario continuare a eseguirli nello stesso ambiente e rispetto al codice di base e alla configurazione dell’app stessa. La spedizione del codice delle attività di amministrazione accanto all’applicazione impedisce la deriva.

Lettura correlata

• BMC DevOps Blog
• Agile vs Waterfall SDLCs: qual è la differenza?
• Deployment Pipelines (CI/CD) nell’ingegneria del software
• Che cos’è Extreme Programming (XP)?
• Come & Perché diventare una fabbrica di software
• Conferenze Top per la programmazione & Sviluppo software