Aggiornamento rolling con burattino, materiale o tessuto

Ho davanti a loro dei server del molo con un loadbalancer. Ora voglio aggiornare la mia applicazione senza tempi di inattività. Quando un molo sta scendendo e non è più raggiungibile, il carico bilanciatore lo rimuove automaticamente dall'elenco, quindi non è questo il problema.

Il problema principale è quello di evitare il tempo di inattività: quindi, devo assicurarsi che solo un molo venga riavviato alla volta – o assicurati che alless N jettys siano online!

Al momento sto utilizzando un semplice script bash in cui ho bisogno di aspettare manualmente per un molo che è tornato online di nuovo prima di riavviare il molo successivo e così via.

Ora bash non è molto ottimale per questo genere di cose e spero che ci siano strumenti più adatti a rendere l'automazione completa. Ad esempio, potrei usare un URL ping semplice http://jetty-number-n.com/ping che risponde OK (200) se il n-th molo è in linea.

Come posso risolvere questo task e con quale strumento?

Grazie a @ceejayoz ho trovato l' aggiornamento di rotolamento per il merito. Ma è ancora sottotermo come dovrei impostare un timeout fisso.

  • Segnalazione dell'uso critico del disco con il tessuto
  • Può essere utilizzato il tessuto per la distribuzione automatica da GitHub?
  • Può usare capistrano o tessuto per configurare un server da zero?
  • Passare nome host come argomento in task Fabric
  • Soluzione per l'installazione di pip installare -E
  • Il tessuto non lancia Nginx in remoto
  • Tessuto usato per lavorare con chiavi ssh, ma non più
  • Se i web server di produzione utilizzano un host gateway per SSH nelle applicazioni di Django anche se Fabric non lo support?
  • 5 Solutions collect form web for “Aggiornamento rolling con burattino, materiale o tessuto”

    Questo è abbastanza facile con l'Ansible. Libro dei giochi pseudo-pericoloso:

     --- - hosts: your_server_group sudo: yes serial: 1 tasks: - shell: reboot now - wait_for: port=22 

    Il sale ha una comoda opzione batch.

     salt -G 'os:RedHat' --batch-size 25% service.restart jetty 

    Riavviare il servizio molo sul 25% dei server RedHat alla volta.

     salt -N group1 -b 2 system.restart 

    Riavviare i server nel gruppo "1" predefinito, 2 alla volta.

    Il burattino ha i concetti di servizi e ordinazione . Ma il burattino viene eseguito su un singolo server. Quindi non ha intuizioni su altri sisthemes in cui è in esecuzione.

    Se voleste usare il burattino, potresti farlo in modo che un server di controllo master abbia uno script init per gestire i servizi di ciascun server. Quindi lo script init eseguirebbe il riavvio su each server e restituirà il codice di stato. Potresti farlo e mettere in catena each riavvio del servizio da questo server e di un ordine, di incatenamento o di notifica e di sottoscrizione per passare alla prossima.

    Potresti anche scrivere una libreria personalizzata per il burattino, che tratterà un server come server di controllo principale, ma invece di utilizzare gli script init. Può utilizzare una libreria Ruby personalizzata per gestire i servizi di ciascun server. È un po 'più complesso da impostare, ma potrebbe funzionare.

    Adesso uso Puppet al lavoro, ma come ha risposto il primo poster, questo non sembra un primo task ideale per il Puppet. Non posso parlare al senso (anche se voglio iniziare a provarlo).

    Il burattino è orientato più verso l'avvio simultaneo dei sisthemes di modifica / riavvio – un demo Puppet viene eseguito su each client e verifica contro un server centrale in un intervallo programmato (each ora di default). Se si desidera coprire la pianificazione predefinita, di solito si utilizza un meccanismo diverso per call burattino.

    Se sei ok con un riavvio simultaneo, riavviando un servizio è questione di definire un manifesto

     file { 'your_war_file.war': ensure => file, source => "puppet:///...", } service { 'jetty': subscribe => File['your_war_file.war'], hasrestart => True, } 

    le direttive sulle risorse, poi spingere il manifesto e lasciare che il burattino faccia la sua cosa. Questo presuppone che sei giusto con la chiamata

     /etc/init.d/jetty restart 

    che può o non essere accettabile o addirittura ansible.

    È anche ansible definire i propri tipi di risorse personalizzate per questo, che è sicuramente al di là di un semplice task di burattino per la prima volta.

    Visita http://forge.puppetlabs.com/ comunque per vedere se qualcun altro ha risolto un problema simile.

    L'attività che si desidera fare può essere fatta usando l'idea, e sicuramente potrebbe essere fatto usando il Puppet. Mi concentrerò su come realizzarlo usando il burattino.

    È ansible distribuire i file WAR in molo utilizzando il fantoccio, utilizzando una risorsa normale "file" e una risorsa definita inizializzata per each applicazione.

    Il burattino verrà scaricato dall'URL specificato (sul tuo padrone di Puppet). Jetty è in grado di ridistribuire i file WAR senza riavviare se la modifica del file WAR cambia. Quindi, se il tuo manifesto crea una copia in $JETTY_HOME/webapps , dovrebbe essere prelevato automaticamente da Jetty. In questo modo (o toccando il context.xml) non è necessario riavviare manualmente Jetty.

    Per scaricare il file WAR dal tuo master Puppet nella tua directory di applicazione, sarà necessario il seguente manifesto (sostituendo $ JETTY_HOME):

     define jetty::deployment($path) { notice("Deploying ${name} to http://$hostname:${appserver-jetty::port}/"), include jetty, file { "$JETTY_HOME/webapps/${name}.war": owner => 'root', source => $path, } } 

    e devi istruire i nodes per get una versione specifica dell'applicazione uno dopo l'altro (dopo che sei sicuro che è stato avviato correttamente su uno dei nodes). Ciò può essere fatto utilizzando un ENC (classificatore di nodes esterni) o, se non si utilizza ENC, modificando la sezione site.pp per ciascun nodo (o gruppo di nodes):

     node jetty-node1 { jetty::deployment { "servlet": path => '/srv/application/Servlet-1.2.3.war' } }, node jetty-node2 { jetty::deployment { "servlet": path => '/srv/application/Servlet-2.0.1.war' } } 

    La linea del include jetty è necessaria solo se si desidera gestire la configuration Jetty tramite il fantoccio usando, ad esempio. https://github.com/maestrodev/puppet-jetty e questa risorsa definita ha bisogno di una variabile appserver-jetty :: $ port. Questo esempio mostra il modo più semplice per controllare esattamente quale versione dell'applicazione è servita da quale nodo. In questo modo è ansible eseguire la scansione della distribuzione, basata sui controlli di salute e distribuire sul nodo2 solo dopo che il nodo1 esegue correttamente la nuova versione.

    Questo esempio è solo per dimostrare il concetto.

    Potrebbe essere utile controllare queste risorse aggiuntive per ulteriori informazioni e idee: Nel ricaricare i contesti: https://stackoverflow.com/questions/13965643/auto-reloading-war-in-jetty-standalone

    Questo è per l'implementazione e la gestione di tomcat, ma le idee (ei manifesti) sono simili: http://www.tomcatexpert.com/blog/2010/04/29/deploying-tomcat-applications-puppet

    Questo è per un'IMO, migliore alternativa alla copia diretta dei file WAR – utilizzando pacchetti native (es. RPM) per la distribuzione dell'applicazione: http://www.slideshare.net/actionjackx/automated-java-deployments-with-rpm

    Suggerimenti per Linux e Windows Server, quali Ubuntu, Centos, Apache, Nginx, Debian e argomenti di rete.