Domanda

Stavo guardando i moduli slave / pool e sembra simile a quello che ho voglio, ma sembra anche che io abbia un singolo punto di errore nel mio applicazione (se il nodo principale scende).

Il client ha un elenco di gateway (per motivi di fallback - tutti lo fanno la stessa cosa) che accetta connessioni e ne viene scelta una a caso dal cliente. Quando il client si connette tutti i nodi sono esaminato per vedere quale ha il minor carico e quindi l'IP del minimo- il server caricato viene inoltrato al client. Il cliente quindi si collega a questo server e tutto viene eseguito lì.

In sintesi, voglio che tutti i nodi fungano da gateway e in realtà elaborare le richieste del cliente. Il bilanciamento del carico viene eseguito solo quando il client inizialmente si connette - tutti i pacchetti effettivi e processati quot & del client; home " nodo.

Come lo farei?

È stato utile?

Soluzione

Non so ancora se questi moduli siano implementati, ma ciò che posso dire è che il bilanciamento del carico è sopravvalutato. Quello che posso sostenere è che la collocazione casuale di posti di lavoro è la soluzione migliore se non si conoscono molte più informazioni su come verrà il carico in futuro e nella maggior parte dei casi non lo si fa davvero. Quello che hai scritto:

  

Quando il client si connette tutti i nodi vengono esaminati per vedere quale ha il minor carico e quindi l'IP del server meno caricato viene inoltrato al client.

Come sai che tutti quei nodi meno caricati non saranno caricati più in alto solo nel prossimo ms? Come fai a sapere che tutti quei nodi con carico elevato che non includerai nell'elenco non lasceranno cadere il carico solo nel prossimo ms? Non puoi davvero saperlo se non hai un caso molto raro.

Basta misurare (o calcolare) le prestazioni del nodo e impostare la probabilità del nodo da scegliere in base a ciò. Scegli il nodo in modo casuale indipendentemente dal carico corrente. Usa questo come approccio iniziale. Quando lo configuri, puoi provare a creare un algoritmo più sofisticato. Scommetto che sarà un duro lavoro battere questo approccio iniziale. Fidati di me, molto difficile.

Modifica : per essere più chiari in un dettaglio sottile, sostengo fortemente che non è possibile prevedere il carico futuro dal carico attuale e storico, ma è necessario utilizzare le conoscenze sulla probabilità di durate delle attività e l'attuale decomposizione di durata dell'attività. Questo lavoro è così difficile da provare a raggiungere.

Altri suggerimenti

Lo scopo di un albero di supervisione è gestire i processi non necessariamente inoltrare richieste. Non vi è alcun motivo per cui non è possibile utilizzare un codice diverso per inviare richieste direttamente ai membri dell'elenco dei processi disponibili. Guarda le funzioni pool: get_nodes o pool: get_node () per un modo per ottenere quegli elenchi.

È possibile consentire al modulo del pool di gestire la gestione dei processi (riavvio, monitoraggio ed elaborazione dell'uccisione) e utilizzare qualche altro modulo per reindirizzare in modo trasparente le richieste al pool di processi. Forse stavi cercando pool distribuiti? Sarà difficile allontanarsi dal processo principale in erlang senza andare a nodi distribuiti. L'intero sistema in esecuzione è praticamente un grande albero di supervisione.

Di recente ho ricordato il modulo pg che consente di impostare gruppi di processi. i messaggi inviati al gruppo vanno a tutti i processi del gruppo. Potrebbe farti strada verso ciò che vuoi. dovresti scrivere il codice per decidere quale processo gestisce realmente la richiesta ma otterrai un pool senza un master che lo utilizza.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top