Pensando pragmaticamente alla scalabilità

Penso che la scalabilità significhi davvero avere la capacità di aggiungere capacità aggiungendo componenti (hardware, in genere) senza che nessun componente individuale diventi sempre più carico con l'aumentare della domanda di sistema. In altre parole, in un sistema scalabile non esiste un componente collo di bottiglia che alla fine limiterà le prestazioni e il throughput. Invece, le prestazioni e il throughput restano idealmente costanti o almeno si riducono più lentamente di quanto la domanda sul sistema non cresca.

Hai ragione a tenere a mente concetti come tolleranza agli errori e alta disponibilità (e la loro implementazione tramite replica), ma li vedo più preoccupati di affidabilità rispetto alla scalabilità . Sebbene spesso implementati insieme, sono due cose diverse.

Nell'esempio del grafico, cosa è necessario ridimensionare?

• È l'accesso al grafico (un gran numero di utenti simultanei)?

• Per quanto riguarda l'accesso, è l'accesso in scrittura che necessita di ridimensionamento o solo l'accesso in lettura?

• È la dimensione del grafico stesso (ad esempio un gran numero di nodi come il social graph di Facebook)?

• E riguardo la complessità? Ogni nodo deve supportare un numero arbitrario di connessioni?

• Ogni nodo (e quindi il sistema nel suo insieme) deve contenere quantità arbitrariamente grandi di dati?

Queste sono alcune questioni pragmatiche che devono essere affrontate quando si parla di scalabilità. Come la maggior parte delle sfide di progettazione, si tratta in realtà di rompere il problema nelle questioni fondamentali che devono essere affrontate.

Infine, vedo tecniche come la programmazione asincrona che contribuiscono all'efficienza , ma non alla scalabilità. A meno che tu non stia facendo qualcosa di importante come la sostituzione di un algoritmo quadratico con uno lineare, le efficienze da sole non saranno di grande aiuto con la scalabilità (vedi Legge di Amdahl ). Aiuteranno con il costo della scalabilità (un problema molto pragmatico), ma non con il potenziale per questo.

La risposta a questa domanda può diventare molto complicata se è necessario supportare richieste parallele mentre è necessario suddividere una singola richiesta su più nodi di elaborazione.

Ci sono 2 tipi di ridimensionamento,

1. Verticale
2. Orizzontale

Per il ridimensionamento verticale (aggiungendo più potenza della CPU / aggiungendo più memoria).

1. Poiché l'operazione avviene in un singolo processo, una delle considerazioni riguarda come distribuire l'operazione in diversi thread e combinare i risultati .

2. Se le richieste parallele devono essere elaborate, anche la concorrenza entra in gioco. E se il singolo grafico viene modificato da più richieste parallele, ciò potrebbe essere molto complicato e potrebbe essere necessario pensare a uno scenario come questo,

If the graph has Node A,B and C where C has links to both A and B, and parallel requests wants to change A and B, then concurrency issue happens on C. One way to sort it is to determine which nodes are affected by each request and queue the conflicting requests, or just to merge the changes. But this depends on your graph

Per il ridimensionamento orizzontale (si verifica in più processi in diversi nodi di elaborazione fisica) e, quando si tratta dell'elaborazione del grafico, puoi migliorare l'elaborazione in modi diversi,

1. Dividere la richiesta tra i nodi di elaborazione per migliorare le prestazioni (bilanciamento del carico) in cui una richiesta viene elaborata da un nodo

e i requisiti sono,

• Memorizza il tuo oggetto grafico in una memoria persistente come un database così che ogni nodo di elaborazione può leggerlo.

• Blocco delle sezioni nella memoria permanente basata sul grafico (simile alle richieste parallele del singolo processo) in modo che le scritture parallele non avvengano e quindi il grafico non viene riempito.

2. Dividi la richiesta tra i nodi in modo che la richiesta data venga elaborata da più nodi di elaborazione

• Tutti i passaggi eseguiti per il bilanciamento del carico

• Suddividi l'elaborazione in più sezioni e distribuisci sui diversi nodi di elaborazione

• Unisci i risultati dei risultati una volta completata l'elaborazione