Passa al contenuto principale

Coordinamento del cluster Enterprise

I nodi Semaphore non comunicano mai direttamente tra loro. Tutto ciò su cui devono accordarsi passa attraverso Redis: chi è attivo, quale task appartiene a quale nodo, chi avvia una pianificazione e quali messaggi dell'interfaccia utente inoltrare. Ogni parte di questo stato è un piccolo insieme di chiavi Redis con una scadenza, quindi un nodo che si blocca non può lasciare nulla alle sue spalle a lungo. I dati durevoli (task, template, log, runner) risiedono sempre nel database; Redis contiene solo lo stato di coordinamento.

Tutte le chiavi usano i prefissi fissi ha: e tasks:. Non sono configurabili, quindi due cluster Semaphore che condividono lo stesso server Redis devono usare numeri di database diversi (ha.redis.db).

Registro dei nodi​

Ogni nodo si registra all'avvio e poi aggiorna il proprio record ogni 10 secondi. Il record scade dopo 30 secondi, quindi un nodo che smette di aggiornarlo viene considerato morto al massimo dopo mezzo minuto. In caso di arresto regolare, il nodo rimuove immediatamente il proprio record.

ChiaveTipoScopo
ha:node:<node_id>stringa, JSONHeartbeat di un nodo: node_id, started_at, version, last_beat. Scade 30 s dopo l'ultimo aggiornamento.
ha:nodessetID di tutti i nodi registrati. I membri la cui chiave di heartbeat è scaduta vengono rimossi dagli altri nodi.

Il registro dei nodi è ciò che mostra la dashboard Cluster ed è ciò che consulta il pulitore dei task orfani (vedi sotto) per decidere se il proprietario di un task è ancora attivo.

Coda dei task e task in esecuzione​

La coda dei task è condivisa, quindi un task avviato su un nodo può essere assegnato, monitorato e finalizzato da qualsiasi altro. Redis memorizza solo gli ID dei task e alcuni campi transitori; il task stesso viene caricato dal database dal nodo che ne ha bisogno.

ChiaveTipoScopo
tasks:queuelistaID dei task in attesa di essere assegnati, in ordine.
tasks:claim:<task_id>stringaID del nodo proprietario del task. Scritto atomicamente insieme alla rimozione dalla coda, così un task viene preso in carico esattamente da un nodo. Scade dopo 5 minuti; il proprietario lo aggiorna ogni minuto.
tasks:runningsetID dei task attualmente in esecuzione.
tasks:active:<project_id>setID dei task attivi (in attesa o in esecuzione) in un progetto. Usato per i limiti di concorrenza per progetto.
tasks:task_projecthashtask_id → project_id, così qualsiasi nodo può caricare il task dal database.
tasks:aliaseshashalias → task_id per i task a cui si fa riferimento tramite un alias.
tasks:runtime:<task_id>hashCampi che cambiano mentre il task è in esecuzione, come l'ID del runner e l'utente che lo ha avviato.
tasks:finalize:<task_id>stringaLock acquisito dal nodo che scrive il risultato finale di un task eseguito su un runner remoto. Scade dopo 5 minuti.

Le voci in tasks:task_project, tasks:aliases e tasks:runtime:* vengono rimosse al termine del task e, come misura di sicurezza, scadono comunque dopo 7 giorni.

Un nodo preleva un task dalla coda con una singola operazione atomica: verifica che il task sia ancora in coda, scrive la presa in carico, rimuove il task dalla coda e lo aggiunge al set dei task in esecuzione. Se due nodi ci provano contemporaneamente, solo uno riesce.

Pulitore dei task orfani. Una volta al minuto ogni nodo esamina i task in esecuzione il cui proprietario è morto, cioè la presa in carico è scaduta o l'heartbeat del proprietario è scomparso. Un task che il database indica già come terminato viene semplicemente rimosso da Redis. Un task che non è mai stato consegnato a un runner viene rimesso in coda, così che un nodo attivo lo assegni. Un task già in esecuzione su un runner viene lasciato stare: il runner continua a lavorare e il task viene ripulito quando il database lo indica come terminato.

Lock​

I lock sono singole chiavi create con SET NX: il nodo che riesce a creare la chiave detiene il lock. Ogni lock ha una scadenza, e i lock mantenuti a lungo vengono aggiornati dal loro proprietario, quindi un nodo che si blocca rilascia automaticamente i propri lock.

ChiaveScadenzaScopo
ha:sched:lock:<schedule_id>:<minute>55 sUn lock per pianificazione per minuto. Il nodo che lo crea avvia la pianificazione; gli altri la saltano.
ha:wf:lock:<project_id>:<run_id>30 s, aggiornato ogni 10 sSolo un nodo alla volta fa avanzare una determinata esecuzione di workflow.
ha:wf:start:<project_id>:<template_id>10 sLock breve durante la creazione di una nuova esecuzione di workflow, così due nodi non avviano lo stesso workflow due volte.
ha:audit:export:<destination_id>30 s, aggiornato ogni 10 sSolo un nodo esporta gli eventi di audit verso una determinata destinazione. Se Redis non è disponibile, nessun nodo esporta, quindi gli eventi non vengono mai inviati due volte.

I lock di pianificazione e di workflow sono "fail open": se Redis non è raggiungibile, il nodo procede invece di saltare il lavoro, e gli aggiornamenti condizionali nel database mantengono corretto il risultato. Il lease dell'esportazione di audit è invece "fail closed", perché un'esportazione duplicata non può essere annullata.

Canali Pub/Sub​

CanaleScopo
ha:ws:broadcastMessaggi WebSocket per l'interfaccia utente. Un nodo consegna un messaggio ai propri browser connessi e lo pubblica qui; gli altri nodi lo inoltrano ai loro.
tasks:eventsModifiche alla coda dei task e al set dei task in esecuzione, aggiornamenti dei campi di runtime e richieste di arresto forzato. I nodi usano questi eventi per mantenere aggiornata la propria vista in memoria della coda e per fermare un task che un altro nodo ha chiesto di fermare.

I messaggi contengono l'ID del nodo mittente, quindi un nodo ignora i propri messaggi.

Chiavi della cache dei runner​

Le chiavi ha:runner:* appartengono alla cache condivisa dei record dei runner. Per maggiori informazioni, vedi Cache di autenticazione dei runner.