Come dividere le versioni di sviluppo / staging / produzione di un'applicazione

2

Sono di fronte a una situazione che non sembra avere una soluzione chiara ad essa, il che mi porta a credere che in realtà stia facendo qualcosa di sbagliato. Eccomi di nuovo in cerca di consigli.

Per farti rapidamente capire il mio problema, sto riscontrando problemi nel rilasciare app / sviluppare app, in termini di separazione del codice di produzione con il codice di sviluppo. Ora lascia che ti spieghi in dettaglio.

Per prima cosa, ecco le due cose che ho fatto in passato:

Sviluppa su un singolo ramo (git), dì "dev", e quando abbiamo bisogno di rilasciare, cambia semplicemente tutto manualmente nello stato "produzione", build-archive-release, e siamo a posto.

Per ovvi motivi, questo è completamente non-disponibile e richiede molto lavoro anche quando si pubblicano app semplici.

Sviluppa su un ramo "dev" e, una volta soddisfatti, ci uniamo su un ramo "beta" e quindi su "produzione" e spediamo qualsiasi ramo che deve essere spedito.

Questo è meglio, ma l'inesorabile fusione sembra altrettanto incline all'errore come "un ramo per dominarli tutti". E per di più, mi sento piuttosto inconsapevole di cosa farà esattamente l'unione nei miei file, quando si tratta di specifici file di configurazione. Ad esempio, unendo dev in beta, quale delle API Keys sceglierà nell'unione? La chiave dev o beta? Lo stesso per alcune credenziali o URL di back-end. Sembra davvero più pulito quando lo guardi dall'esterno, ma alla fine, continuo a controllare tutti i miei file uno per uno. E ho avuto brutti cambiamenti, non sono solo paranoico, purtroppo.

Quindi, direi meglio, ma altrettanto manutenibile.

Alcuni hanno consigliato di usare #IF DEBUG , ma io sono contro di esso, finendo per ingombrare il codice e avere frammenti di due diversi ambienti sparsi nel codice. Alla fine non stai nemmeno testando il prodotto reale, quindi non può funzionare.

E ora eccomi qui, non sapendo cosa fanno gli altri e come loro superano quell'ostacolo. Sono tutto orecchie.

Nota: ho letto un po 'sui build server ma non sono sicuro di averli veramente compresi, e dal mio punto di vista inesperto, li vedo solo come spostare il problema su una macchina remota, che non cambia molto.

    
posta Gil Sand 09.08.2016 - 10:02
fonte

2 risposte

1

Dai un'occhiata a 12factor.net. Ha molti buoni consigli sulla manutenibilità delle app.

Suggeriscono di archiviare tutte le configurazioni nell'ambiente come variabili ambientali. Penso che sia difficile ridimensionarlo senza metterne alcuni in un file di configurazione selezionato per l'ambiente, ma io strongmente> non sono d'accordo con qualcuno che dice che metti tutte le variabili modificabili in un file che impacchettate con il codice dell'applicazione . Questa è un'enorme possibilità di perdere casualmente password e altri elementi relativi alla sicurezza se non si è estremamente cauti.

Tendo ad adottare un approccio ibrido, che accetterà le variabili di env vars se non sono in un file statico. Quindi semplicemente non inserisco variabili sensibili nel file, ma invece configuro l'account di servizio dei sistemi di produzione insieme a loro (una volta), in modo che non vengano mai archiviati.

Se si dispone di un processo CI / CD, è possibile avere un file locale (idealmente crittografato) utilizzato per configurare tali variabili al momento della distribuzione, se si preferisce che il passaggio manuale venga rimosso.

    
risposta data 09.08.2016 - 12:41
fonte
1

Vorrei strongmente sconsigliare diversi rami per separare configurazioni di sviluppo apparentemente dure da configurazioni di produzione. L'utilizzo di SCM per questa attività porterà a basi di codice sempre più diverse.

Un ottimo modo per rendere esplicite le differenze di build è creare un sottoprogetto per obiettivo di costruzione. In questi progetti è possibile estendere ad esempio un programma di avvio generico dal codice principale o fornire parametri specifici per l'ambiente. Anche se si utilizzano i file di configurazione, un progetto per ciascun obiettivo di creazione è spesso un buon posto in cui inserire i file di configurazione.

Un layout del progetto potrebbe apparire in questo modo:

  • application (root-project)
    • applicazione principale
    • application-distribution-prod (usa application-main)
    • application-distribution-dev (usa application-main)

Quando la tua applicazione è grande e ha moduli diversi, puoi creare diversi moduli assemblati semplicemente creando diversi sottoprogetti di distribuzione.

Quando hai differenze complesse tra gli ambienti di produzione e di sviluppo, ti consiglio di inserire tutti gli aspetti variabili nelle interfacce. Quindi implementate tali interfacce in due diversi progetti. Il passaggio da un ambiente all'altro diventa una questione di gestione delle dipendenze.

Un esempio esteso:

  • application (root-project)
    • applicazione principale
    • application-login-mock (implementa l'API di accesso da application-main)
    • application-login-google (implementa login API da application-main)
    • application-distribution-prod (usa application-main & application-login-google)
    • application-distribution-dev (usa application-main & application-login-mock)

Per questa tecnica avrai bisogno di un tipo di iniezione di dipendenza o di un fornitore di servizi.

    
risposta data 10.08.2016 - 00:54
fonte