Spark Standalone kümesinde çalışanlar, uygulayıcılar, çekirdekler nelerdir?

Küme Moduna Genel Bakış'ı okudum ve Kıvılcım Bağımsız kümedeki farklı işlemleri ve paralelliği hala anlayamıyorum .

Çalışan bir JVM süreci mi, değil mi? bin\start-slave.shKoştum ve aslında bir JVM olan işçiyi doğurduğunu gördüm .

Yukarıdaki bağlantıya göre, bir yönetici, görevleri çalıştıran bir çalışan düğümdeki bir uygulama için başlatılan bir işlemdir. Bir uygulayıcı da JVM'dir.

Bunlar benim sorularım:

1. Uygulayıcılar başvuru başınadır. O zaman bir işçinin rolü nedir? Uygulayıcı ile koordine oluyor ve sonucu sürücüye iletiyor mu? Yoksa sürücü doğrudan uygulayıcıyla mı konuşuyor? Eğer öyleyse, işçinin amacı nedir?

2. Bir uygulama için yürütücü sayısını nasıl kontrol edebilirim?

3. Görevler icracı içinde paralel olarak gerçekleştirilebilir mi? Öyleyse, bir yürütücü için iş parçacığı sayısı nasıl yapılandırılır?

4. Bir işçi, uygulayıcılar ve yürütücü çekirdeği (--total-uygulayıcı-çekirdeği) arasındaki ilişki nedir?

5. Düğüm başına daha fazla işçi bulundurmak ne demektir?

Güncellenmiş

Daha iyi anlamak için örnekler alalım.

Örnek 1: 5 çalışan düğümü olan bağımsız bir küme (her düğümün 8 çekirdeği vardır) Bir uygulamayı varsayılan ayarlarla başlattığımda.

Örnek 2 Örnek 1 ile aynı küme yapılandırması, ancak aşağıdaki ayarlara sahip bir uygulama çalıştırıyorum - executor-cores 10 --total-executor-cores 10.

Örnek 3 Örnek 1 ile aynı küme yapılandırması, ancak aşağıdaki ayarlara sahip bir uygulama çalıştırıyorum - executor-cores 10 --total-executor-cores 50.

Örnek 4 Örnek 1 ile aynı küme yapılandırması, ancak aşağıdaki ayarlarla bir uygulama çalıştırıyorum - executor-cores 50 --total-executor-cores 50.

Örnek 5 Örnek 1 ile aynı küme yapılandırması, ancak aşağıdaki ayarlarla bir uygulama çalıştırıyorum - executor-cores 50 --total-executor-cores 10.

Bu örneklerin her birinde kaç uygulayıcı var? Yürütücü başına kaç iş parçacığı? Kaç tane çekirdek? Uygulama başına icracı sayısına nasıl karar verilir? Her zaman işçi sayısıyla aynı mıdır?

Spark bir master / slave mimarisi kullanır. Şekilde görebileceğiniz gibi, birçok dağıtılmış işçiyle (uygulayıcı) iletişim kuran bir merkezi koordinatöre (Sürücü) sahiptir. Sürücü ve her yürütücü kendi Java işlemlerinde çalışır.

SÜRÜCÜ

Sürücü, ana yöntemin çalıştığı süreçtir. İlk olarak kullanıcı programını görevlere dönüştürür ve daha sonra görevleri yürütücüler üzerinde zamanlar.

executors

Yürütücüler, belirli bir Spark işinde bireysel görevleri yürütmekten sorumlu çalışan düğümlerin süreçleridir. Bir Spark uygulamasının başlangıcında başlatılırlar ve genellikle bir uygulamanın tüm ömrü boyunca çalışırlar. Görevi çalıştırdıktan sonra sonuçları sürücüye gönderirler. Ayrıca Block Manager aracılığıyla kullanıcı programları tarafından önbelleğe alınan RDD'ler için bellek içi depolama sağlar.

UYGULAMA YÜRÜTME AKIŞI

Bunu göz önünde bulundurarak, kümeye kıvılcım-gönderme ile bir başvuru gönderdiğinizde, dahili olarak olan budur:

1. Bağımsız bir uygulama başlar ve bir SparkContextörneği başlatır (ve ancak o zaman uygulamayı bir sürücü olarak adlandırabildiğinizde).
2. Sürücü programı, yöneticileri başlatmak için küme yöneticisine kaynak ister.
3. Küme yöneticisi uygulayıcıları başlatır.
4. Sürücü işlemi kullanıcı uygulaması üzerinden gerçekleştirilir. Eylemlere ve RDD'ler üzerindeki dönüşümlere bağlı olarak görev yöneticilere gönderilir.
5. Yürütücüler görevleri yürütür ve sonuçları kaydeder.
6. Herhangi bir işçi çökerse görevleri yeniden işlenmek üzere farklı yöneticilere gönderilir. "Kıvılcım Öğrenme: Yıldırım Hızında Büyük Veri Analizi" kitabında Kıvılcım ve Hata Toleransı hakkında konuşuyorlar:

Spark, başarısız veya yavaş görevleri yeniden yürüterek başarısız veya yavaş makineleri otomatik olarak ele alır. Örneğin, bir map () işleminin bir bölümünü çalıştıran düğüm çökerse, Spark başka bir düğümde yeniden çalıştırır; ve düğüm çökmese de diğer düğümlerden çok daha yavaş olsa bile, Spark önleyici olarak görevin başka bir düğümde "spekülatif" bir kopyasını başlatabilir ve bu sonuç sona ererse sonucunu alabilir.

7. Sürücüden SparkContext.stop () ile veya ana yöntem çıkarsa / kilitlenirse tüm yürütücüler sonlandırılır ve küme kaynakları küme yöneticisi tarafından serbest bırakılır.

SORULARINIZ

1. Yürütücüler başlatıldığında kendilerini sürücüye kaydederler ve böylece doğrudan iletişim kurarlar. İşçiler, küme yöneticisine kaynaklarının kullanılabilirliğini bildirmekten sorumludur.

2. Bir İPLİK kümesinde bunu --num-execrators ile yapabilirsiniz. Bağımsız bir kümede, spark.executor.cores ile oynamadıkça ve bir çalışanın birden fazla yürütücüyü tutmak için yeterli çekirdeğe sahip olmadıkça, çalışan başına bir yürütücü alırsınız. (@JacekLaskowski'nin işaret ettiği gibi, --num-uygulayıcıları artık YARN'da kullanımda değil https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. Her yürütücü başına çekirdek sayısını --executor çekirdeği ile atayabilirsiniz

4. --total-executor-cores, uygulama başına maksimum icra çekirdek sayısıdır

5. Sean Owen bu söylediği gibi iplik : "makine başına birden çok işçi çalıştırmak için iyi bir neden yok". Örneğin, bir makinede oturan birçok JVM'niz olur.

GÜNCELLEME

Bu senaryoları test edemedim, ancak belgelere göre:

ÖRNEK 1: Spark iştah açıcı tarafından zamanlayıcı tarafından sunulan sayıda çekirdek ve uygulayıcı edinecek. Sonuçta her biri 8 çekirdek olan 5 uygulayıcı alacaksınız.

ÖRNEK 2 ila 5: Spark, tek bir işçide istendiği kadar çok çekirdek tahsis edemez, dolayısıyla hiçbir yürütücü başlatılamaz.

Apache Spark dahili olarak şu şekilde çalışır: