ロード方法Spark Cassandra=シェルのコネクタ？
Spark Cassandra Connector in Spark 1.1.0を使用しようとしています。
GitHubのmasterブランチからjarファイルを正常にビルドし、含まれているデモを機能させることができました。ただし、jarファイルをspark-Shellにロードしようとすると、com.datastax.spark.connectorパッケージからクラスをインポートできません。
--jarsでspark-Shellオプションを使用して、jarファイルのあるディレクトリをJavaのCLASSPATHに追加しようとしました。これらのオプションはどちらも機能しません。実際、--jarsオプションを使用すると、ロギング出力にDatastax jarがロードされていることが示されますが、com.datastaxからは何もインポートできません。
Tuplejump Calliope Cassandraコネクタをspark-Shellを使用して--jarsに読み込むことができたので、動作していることがわかります。私にとって失敗しているのは、Datastaxコネクタだけです。
わかった。以下は私がしたことです：
$ git clone https://github.com/datastax/spark-cassandra-connector.git
$ cd spark-cassandra-connector
$ sbt/sbt Assembly
$ $SPARK_HOME/bin/spark-Shell --jars ~/spark-cassandra-connector/spark-cassandra-connector/target/scala-2.10/connector-Assembly-1.2.0-SNAPSHOT.jar
scala Prompt、
scala> sc.stop
scala> import com.datastax.spark.connector._
scala> import org.Apache.spark.SparkContext
scala> import org.Apache.spark.SparkContext._
scala> import org.Apache.spark.SparkConf
scala> val conf = new SparkConf(true).set("spark.cassandra.connection.Host", "my cassandra Host")
scala> val sc = new SparkContext("spark://spark Host:7077", "test", conf)
編集：物事が少し簡単になりました
詳細な手順については、プロジェクトのWebサイトをご覧ください https://github.com/datastax/spark-cassandra-connector/blob/master/doc/13_spark_Shell.md
または、Spark-Packagesを使用してライブラリをロードしてください（すべてのバージョンが公開されているわけではありません） http://spark-packages.org/package/datastax/spark-cassandra-connector
> $SPARK_HOME/bin/spark-Shell --packages com.datastax.spark:spark-cassandra-connector_2.10:1.4.0-M3-s_2.10
以下は、OSS Apache C *で実行していることを前提としています
すべてのコネクタライブラリを含めるために、-driver-class-pathを設定してクラスを開始する必要があります。
著名な Amy Tobey からのブログ投稿を引用します
私が見つけた最も簡単な方法は、クラスパスを設定してからREPLでコンテキストを再起動し、sc.cassandraTable（）を表示するために必要なクラスをインポートします。新しくロードされたメソッドは表示されません。タブ補完で起動します。理由はわかりません。
/opt/spark/bin/spark-Shell --driver-class-path $(echo /path/to/connector/*.jar |sed 's/ /:/g')
大量のログ情報を出力し、scala>プロンプトを表示します。
scala> sc.stop
コンテキストが停止したので、今度はコネクタをインポートします。
scala> import com.datastax.spark.connector._
scala> val conf = new SparkConf()
scala> conf.set("cassandra.connection.Host", "node1.pc.datastax.com")
scala> val sc = new SparkContext("local[2]", "Cassandra Connector Test", conf)
scala> val table = sc.cassandraTable("keyspace", "table")
scala> table.count
DSE <4.5.1で実行している場合
DSE Classloaderと以前のパッケージ命名規則にはわずかな問題があり、新しいスパークコネクタライブラリを見つけることができません。この問題を回避するには、spark-Shellを起動するスクリプトでDSEクラスローダーを指定する行を削除する必要があります。
シェルでコンテキストの停止/開始を回避する場合は、次のようにsparkプロパティに追加することもできます。
{spark_install} /conf/spark-defaults.conf
spark.cassandra.connection.Host=192.168.10.10
Spark-ShellからCassandraにアクセスするには、すべての依存関係（「uberjar」）を使用してcassandra-spark-driverからアセンブリを構築しました。次のような--jarsオプション：
spark-Shell --jars spark-cassandra-Assembly-1.0.0-SNAPSHOT-jar-with-dependencies.jar
私はここで説明した同じ問題に直面していましたが、この方法はシンプルで便利です（依存関係の長いリストをロードする代わりに）
download できるPOMファイルを使用してGistを作成しました。 pomを使用してuberjarを作成します：
mvn package
Sbtを使用している場合は、sbt-Assemblyプラグインを調べてください。
Spark-Cassandra-Connector完全なコードJava Window-7,8,10で有用。
import com.datastax.driver.core.Session;
import com.datastax.spark.connector.cql.CassandraConnector;
import com.google.common.base.Optional;
import org.Apache.spark.SparkConf;
import org.Apache.spark.api.Java.JavaPairRDD;
import org.Apache.spark.api.Java.JavaRDD;
import org.Apache.spark.api.Java.JavaSparkContext;
import org.Apache.spark.api.Java.function.FlatMapFunction;
import org.Apache.spark.api.Java.function.Function;
import org.Apache.spark.api.Java.function.Function2;
import org.Apache.spark.api.Java.function.PairFlatMapFunction;
import scala.Tuple2;
import spark_conn.Spark_connection;
import Java.io.Serializable;
import Java.math.BigDecimal;
import Java.text.MessageFormat;
import Java.util.*;
import static com.datastax.spark.connector.CassandraJavaUtil.*;
public class App implements Serializable
{
private transient SparkConf conf;
private App(SparkConf conf) {
this.conf = conf;
}
private void run() {
JavaSparkContext sc = new JavaSparkContext(conf);
generateData(sc);
compute(sc);
showResults(sc);
sc.stop();
}
private void generateData(JavaSparkContext sc) {
CassandraConnector connector = CassandraConnector.apply(sc.getConf());
// Prepare the schema
try{
Session session=connector.openSession();
session.execute("DROP KEYSPACE IF EXISTS Java_api");
session.execute("CREATE KEYSPACE Java_api WITH
replication = {'class': 'SimpleStrategy', 'replication_factor': 1}");
session.execute("CREATE TABLE Java_api.products
(id INT PRIMARY KEY, name TEXT, parents LIST<INT>)");
session.execute("CREATE TABLE Java_api.sales
(id UUID PRIMARY KEY, product INT, price DECIMAL)");
session.execute("CREATE TABLE Java_api.summaries
(product INT PRIMARY KEY, summary DECIMAL)");
}catch(Exception e){System.out.println(e);}
// Prepare the products hierarchy
List<Product> products = Arrays.asList(
new Product(0, "All products", Collections.<Integer>emptyList()),
new Product(1, "Product A", Arrays.asList(0)),
new Product(4, "Product A1", Arrays.asList(0, 1)),
new Product(5, "Product A2", Arrays.asList(0, 1)),
new Product(2, "Product B", Arrays.asList(0)),
new Product(6, "Product B1", Arrays.asList(0, 2)),
new Product(7, "Product B2", Arrays.asList(0, 2)),
new Product(3, "Product C", Arrays.asList(0)),
new Product(8, "Product C1", Arrays.asList(0, 3)),
new Product(9, "Product C2", Arrays.asList(0, 3))
);
JavaRDD<Product> productsRDD = sc.parallelize(products);
javaFunctions(productsRDD, Product.class).
saveToCassandra("Java_api", "products");
JavaRDD<Sale> salesRDD = productsRDD.filter
(new Function<Product, Boolean>() {
@Override
public Boolean call(Product product) throws Exception {
return product.getParents().size() == 2;
}
}).flatMap(new FlatMapFunction<Product, Sale>() {
@Override
public Iterable<Sale> call(Product product) throws Exception {
Random random = new Random();
List<Sale> sales = new ArrayList<>(1000);
for (int i = 0; i < 1000; i++) {
sales.add(new Sale(UUID.randomUUID(),
product.getId(), BigDecimal.valueOf(random.nextDouble())));
}
return sales;
}
});
javaFunctions(salesRDD, Sale.class).saveToCassandra
("Java_api", "sales");
}
private void compute(JavaSparkContext sc) {
JavaPairRDD<Integer, Product> productsRDD = javaFunctions(sc)
.cassandraTable("Java_api", "products", Product.class)
.keyBy(new Function<Product, Integer>() {
@Override
public Integer call(Product product) throws Exception {
return product.getId();
}
});
JavaPairRDD<Integer, Sale> salesRDD = javaFunctions(sc)
.cassandraTable("Java_api", "sales", Sale.class)
.keyBy(new Function<Sale, Integer>() {
@Override
public Integer call(Sale sale) throws Exception {
return sale.getProduct();
}
});
JavaPairRDD<Integer, Tuple2<Sale, Product>> joinedRDD = salesRDD.join(productsRDD);
JavaPairRDD<Integer, BigDecimal> allSalesRDD = joinedRDD.flatMapToPair(new PairFlatMapFunction<Tuple2<Integer, Tuple2<Sale, Product>>, Integer, BigDecimal>() {
@Override
public Iterable<Tuple2<Integer, BigDecimal>> call(Tuple2<Integer, Tuple2<Sale, Product>> input) throws Exception {
Tuple2<Sale, Product> saleWithProduct = input._2();
List<Tuple2<Integer, BigDecimal>> allSales = new ArrayList<>(saleWithProduct._2().getParents().size() + 1);
allSales.add(new Tuple2<>(saleWithProduct._1().getProduct(), saleWithProduct._1().getPrice()));
for (Integer parentProduct : saleWithProduct._2().getParents()) {
allSales.add(new Tuple2<>(parentProduct, saleWithProduct._1().getPrice()));
}
return allSales;
}
});
JavaRDD<Summary> summariesRDD = allSalesRDD.reduceByKey(new Function2<BigDecimal, BigDecimal, BigDecimal>() {
@Override
public BigDecimal call(BigDecimal v1, BigDecimal v2) throws Exception {
return v1.add(v2);
}
}).map(new Function<Tuple2<Integer, BigDecimal>, Summary>() {
@Override
public Summary call(Tuple2<Integer, BigDecimal> input) throws Exception {
return new Summary(input._1(), input._2());
}
});
javaFunctions(summariesRDD, Summary.class).saveToCassandra("Java_api", "summaries");
}
private void showResults(JavaSparkContext sc) {
JavaPairRDD<Integer, Summary> summariesRdd = javaFunctions(sc)
.cassandraTable("Java_api", "summaries", Summary.class)
.keyBy(new Function<Summary, Integer>() {
@Override
public Integer call(Summary summary) throws Exception {
return summary.getProduct();
}
});
JavaPairRDD<Integer, Product> productsRdd = javaFunctions(sc)
.cassandraTable("Java_api", "products", Product.class)
.keyBy(new Function<Product, Integer>() {
@Override
public Integer call(Product product) throws Exception {
return product.getId();
}
});
List<Tuple2<Product, Optional<Summary>>> results = productsRdd.leftOuterJoin(summariesRdd).values().toArray();
for (Tuple2<Product, Optional<Summary>> result : results) {
System.out.println(result);
}
}
public static void main(String[] args) {
// if (args.length != 2) {
// System.err.println("Syntax: com.datastax.spark.demo.App <Spark Master URL> <Cassandra contact point>");
// System.exit(1);
// }
// SparkConf conf = new SparkConf(true)
// .set("spark.cassandra.connection.Host", "127.0.1.1")
// .set("spark.cassandra.auth.username", "cassandra")
// .set("spark.cassandra.auth.password", "cassandra");
//SparkContext sc = new SparkContext("spark://127.0.1.1:9045", "test", conf);
//return ;
/* try{
SparkConf conf = new SparkConf(true);
conf.setAppName("Spark-Cassandra Integration");
conf.setMaster("yarn-cluster");
conf.set("spark.cassandra.connection.Host", "192.168.1.200");
conf.set("spark.cassandra.connection.rpc.port", "9042");
conf.set("spark.cassandra.connection.timeout_ms", "40000");
conf.set("spark.cassandra.read.timeout_ms", "200000");
System.out.println("Hi.......Main Method1111...");
conf.set("spark.cassandra.auth.username","cassandra");
conf.set("spark.cassandra.auth.password","cassandra");
System.out.println("Connected Successful...!\n");
App app = new App(conf);
app.run();
}catch(Exception e){System.out.println(e);}*/
SparkConf conf = new SparkConf();
conf.setAppName("Java API demo");
// conf.setMaster(args[0]);
// conf.set("spark.cassandra.connection.Host", args[1]);
conf.setMaster("spark://192.168.1.117:7077");
conf.set("spark.cassandra.connection.Host", "192.168.1.200");
conf.set("spark.cassandra.connection.port", "9042");
conf.set("spark.ui.port","4040");
conf.set("spark.cassandra.auth.username","cassandra");
conf.set("spark.cassandra.auth.password","cassandra");
App app = new App(conf);
app.run();
}
public static class Product implements Serializable {
private Integer id;
private String name;
private List<Integer> parents;
public Product() { }
public Product(Integer id, String name, List<Integer> parents) {
this.id = id;
this.name = name;
this.parents = parents;
}
public Integer getId() { return id; }
public void setId(Integer id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public List<Integer> getParents() { return parents; }
public void setParents(List<Integer> parents) { this.parents = parents; }
@Override
public String toString() {
return MessageFormat.format("Product'{'id={0}, name=''{1}'', parents={2}'}'", id, name, parents);
}
}
public static class Sale implements Serializable {
private UUID id;
private Integer product;
private BigDecimal price;
public Sale() { }
public Sale(UUID id, Integer product, BigDecimal price) {
this.id = id;
this.product = product;
this.price = price;
}
public UUID getId() { return id; }
public void setId(UUID id) { this.id = id; }
public Integer getProduct() { return product; }
public void setProduct(Integer product) { this.product = product; }
public BigDecimal getPrice() { return price; }
public void setPrice(BigDecimal price) { this.price = price; }
@Override
public String toString() {
return MessageFormat.format("Sale'{'id={0}, product={1}, price={2}'}'", id, product, price);
}
}
public static class Summary implements Serializable {
private Integer product;
private BigDecimal summary;
public Summary() { }
public Summary(Integer product, BigDecimal summary) {
this.product = product;
this.summary = summary;
}
public Integer getProduct() { return product; }
public void setProduct(Integer product) { this.product = product; }
public BigDecimal getSummary() { return summary; }
public void setSummary(BigDecimal summary) { this.summary = summary; }
@Override
public String toString() {
return MessageFormat.format("Summary'{'product={0}, summary={1}'}'", product, summary);
}
}
}
以下の手順は、Spark =Nodeとa Cassandra Node。
オープンソーススパークのセットアップ
これは、Cassandra= setup。
ステップ1：Sparkをダウンロードしてセットアップする
Go to http://spark.Apache.org/downloads.html.
a）物事を簡単にするために、ビルド済みSparkパッケージのいずれかを使用します。Sparkバージョン2.0.0およびビルド済みHadoop 2.7の場合はDirectダウンロード：これにより、Spark用のビルドされたバイナリを含むアーカイブがダウンロードされます。
b）これを選択したディレクトリに抽出します。 〜/ apps/spark-1.2に配置します
c）テストSparkはシェルを開いて動作しています
ステップ2：Spark Works
a）Sparkディレクトリにcdします。「./ bin/spark-Shell」を実行します。これにより、Sparkインタラクティブシェルプログラムが開きます。
b）すべてが機能した場合、次のプロンプトが表示されます： "scala>"
簡単な計算を実行します。
sc.parallelize（1から50）.sum（+）これは1250を出力します。
c）おめでとうSparkは機能しています！コマンド「exit」でシェルを終了Spark=
Spark=Cassandra Connector
Spark= Cassandra=クラスターに接続するには、CassandraコネクターをSparkプロジェクト。DataStaxは独自のCassandra GitHubのコネクタを提供します。これを使用します。
Spark= Cassandraコネクタリポジトリ：
cd into "spark-cassandra-connector" Build Spark Cassandraコマンドを実行してコネクタ
./sbt/sbt Dscala-2.11 = trueアセンブリ
これにより、コンパイルされたjarファイルが「target」という名前のディレクトリに出力されます。 2つのjarファイルがあります。1つはScala用で、もう1つはJava用です。関心のあるjarは次のとおりです。 jarファイルを見つけやすいディレクトリに移動します：私は〜/ apps/spark-1.2/jarsに私のものを置きます
コネクタをSpark Shell：にロードするには
次のコマンドでシェルを開始します。
../bin/spark-Shell –jars〜/ apps/spark-1.2/jars/spark-cassandra-connector-Assembly-1.1.1-SNAPSHOT.jar
Spark ContextをCassandra=クラスターに接続し、デフォルトのコンテキストを停止します。
sc.stop
必要なjarファイルをインポートします。
import com.datastax.spark.connector._, org.Apache.spark.SparkContext, org.Apache.spark.SparkContext._, org.Apache.spark.SparkConf
Cassandra接続の詳細を使用して新しいSparkConfを作成します。
val conf = new SparkConf（true）.set（ "spark.cassandra.connection.Host"、 "localhost"）
新しいSpark Context：
val sc = new SparkContext（conf）
これで、Cassandra=クラスターに接続された新しいSparkContextが作成されました。