Distribuzione a più server EC2 con tessuto

Question

mi chiedo se qualcuno ha esperienza la distribuzione su più server dietro un bilanciatore di carico su EC2 con fabric

ho usato tessuto per un po 'di tempo, e non hanno problemi con esso, o la distribuzione su più server, ma quello che mi piacerebbe fare in questo scenario è (diciamo che ho dieci istanze in esecuzione) de-register metà (5) delle scatole dal mio bilanciamento del carico, distribuire il mio codice a loro ed eseguire un fumo test, e se tutto sembra a posto, registrarli nuovamente con il servizio di bilanciamento del carico e deselezionare le restanti 5 istanze e distribuirle, quindi registrarle nuovamente al servizio di bilanciamento del carico.

Non ho alcun problema a realizzare nessuno dei singoli compiti (de-registrazione, esecuzione di test, distribuzione ecc.), Non so come organizzare i miei host in modo semplice in modo da poter distribuire il primo semestre, poi la seconda metà. Fabric sembra essere impostato per eseguire le stesse attività su tutti gli host in ordine (task 1 su host 1, task 1 su host 2, task 2 su host 1, task 2 su host 2 etc etc)

Il mio primo pensiero era quello di creare un'attività per gestire la prima parte della de-registrazione, la distribuzione e il test, e quindi impostare il env.hosts per la seconda metà dei server, ma ho sentito questo sembrava un po 'hokey.

Qualcuno ha mai modellato qualcosa di simile a questo con Fabric?

Answer 1

È possibile semplificare questo definendo i ruoli (utilizzato per l'aggregazione di host) ed eseguendo le attività su un ruolo, quindi eseguendo test e distribuendo sul secondo ruolo.

Esempio di roledefs:

env.roledefs = { 
    'first_half': ['host1', 'host2'], 
    'second_half': ['host3', 'host4'], 
} 

def deploy_server(): 
    ... 
    # deploy one host from current role here 

def deploy(): 
    # first role: 
    env.roles = ['first_half'] 
    execute('deploy_server') 
    test() # here test deployed servers 
    # second role: 
    env.roles = ['second_half'] 
    execute('deploy_server') 

Altri link:

• env.roledefs documentation,
• env.roles documentation,
• execution model,
• execute() documentation,

Answer 2

Fabric non è configurato per eseguire le stesse attività su tutti gli host.

A parte il fatto che è possibile impostare in modo esplicito i padroni di casa per una specifica compito con il parametro di riga di comando -H, è possibile utilizzare this modello e this più nuovo modello di fare esattamente quello che vuoi.

Aggiornamento: Here mostra come è possibile utilizzare roles

Answer 3

Invece di immischiarsi con env.hosts, si potrebbe passare un elenco (o qualsiasi iterabile) al host decoratore. Qualcosa di simile:

def deploy(half_my_hosts): 
    @hosts(half_my_hosts) 
    def mytask(): 
     # ... 
    mytask() 

allora si potrebbe dividere i env.hosts in qualsiasi modo ti piace e passarlo a distribuire()

Answer 4

Si desidera utilizzare la funzione execute(). Questo vi permetterà di fare qualcosa di simile:

def update(): 
    deallocate() 
    push_code() 
    smoke_test() #could fail fast 
    reallocate() 

def deploy(): 
    execute(update, hosts=first_five) 
    execute(update, hosts=last_five) 

Si potrebbe anche fare ciascuna delle deallocare, push_code, e smoke_test, le attività di un execute() chiamata nel deploy, e poi si sarebbe eseguire tutte le dealloca quindi esegui tutte le spinte di codice, ecc.

Quindi verifica un qualche tipo e poi procedi con gli altri che eseguono tali compiti.

Answer 5

Ho combinato con successo Fabric con boto. Compilo l'elenco degli host usando boto. Puoi usare @parallel decorator per limitare il numero di host da eseguire in un colpo solo. Il comando appare come segue;

fab running deploy

Il codice sembra così;

@task 
@runs_once 
def running(): 
    ec2conn = ec2.connect_to_region(region) 
    reservations = ec2conn.get_all_instances(filters={'instance-state-name': 'running'}) 
    instances = list(chain.from_iterable(map(lambda r: r.instances, reservations))) 
    env.hosts = list(chain.from_iterable(map(lambda i: i.public_dns_name, instances))) 

@task 
@parallel(pool_size=5) 
def deploy(): 
    # do stuff on n<=5 hosts in parallel 

Se è necessario gestire una sottosezione di host, suggerirei di utilizzare i tag.

Answer 6

Oppure si potrebbe semplicemente scrivere un metodo che definisce alcune variabili, per esempio:

def live(): 
    global PATH, ENV_PATH 
    env.hosts = ["22.2.222.2"] 
    env.user = 'test' 
    PATH = '/path/to/project' 
    # optional, is using virtualenv 
    ENV_PATH = '/path/to/virtualenv' 
    # overwri 

te qualunque variabled è necessario cambiare la macchina corrente

e prima di eseguire il comando deploy, eseguire:

fab live deploy 

Dettagli: http://simionbaws.ro/programming/deploy-with-fabric-on-multiple-servers/