现在很多互联网公司都用Cassandra存海量的时序数据或者用户行为数据,而Spark作为大数据分析的主力,常用来对这些数据做统计、画像之类的分析。但直接用Spark连Cassandra干活,经常会碰到读数据慢、写数据失败、甚至把Cassandra节点搞崩的情况——这不是技术不行,是没做好连接调优。接下来就从读写并发、本地感知策略、资源隔离这三个核心点,讲怎么把这俩工具连得顺滑。

一、从常见的连接坑说起

1.1 没调优会遇到啥麻烦?

比如拿电商用户行为数据举例,一天下来有10TB的点击、浏览数据,用Spark跑用户活跃统计,没调的话,可能要跑几个小时,还经常报“Cassandra连接超时”或者“连接数满了”的错;有时候Spark分析任务占了太多Cassandra的资源,连Cassandra本身的实时写入都卡住了,影响前端用户的查询。这些问题本质上是Spark和Cassandra的连接没有匹配双方的承载能力,导致资源浪费或者过载。

二、读写并发的调优:让数据快起来

2.1 读并发:别让Spark挤着读Cassandra

Spark读Cassandra的时候,默认会把数据分成多个分区读取,但如果分区数太少,或者每个分区的数据量太大,不仅单个任务耗时久,还会让多个Spark任务挤在同一个Cassandra节点上,把节点的带宽、连接数耗光,反而拖慢整体速度。调读并发的核心是让Spark的读任务均匀分布到Cassandra的多个节点上,同时控制每个节点的并发连接数。 示例采用单一技术栈:Spark 3.3、Cassandra Connector 3.5、Scala 2.12,代码如下:

// Spark读取Cassandra的读并发调优示例
import org.apache.spark.sql.SparkSession

object CassandraReadTuning {
  def main(args: Array[String]): Unit = {
    // 构建SparkSession,配置读相关调优参数
    val spark = SparkSession.builder()
      .appName("SparkCassandraReadTuning")
      // 每个Cassandra分片的大小,设为1MB,适合中小数据集;大数据量可调整为10MB左右,避免分片太碎
      .config("spark.cassandra.input.split.size", "1048576")
      // 单个Spark executor的读并发数,控制同时连Cassandra的读连接,避免挤爆节点,根据节点连接上限设为8左右
      .config("spark.cassandra.concurrent.reads", "8")
      .master("local[*]") // 本地测试用,生产环境需去掉
      .getOrCreate()

    // 读取Cassandra的用户行为表,keyspace和table需对应实际配置
    val userBehaviorDF = spark.read
      .format("org.apache.spark.sql.cassandra")
      .options(Map(
        "keyspace" -> "user_db",
        "table" -> "behavior"
      ))
      .load()

    // 计算每日活跃用户数,简单演示分析逻辑
    userBehaviorDF.groupBy("date").count().show()

    spark.stop()
  }
}

应用场景:电商的用户画像分析,需读全量用户行为数据,调读并发后读时间可从数小时缩短至数十分钟。技术优缺点:优点是读吞吐量提升、延迟降低;缺点是并发设置过高会超过Cassandra节点的最大连接数,导致连接失败。注意事项:需提前查看Cassandra节点的最大连接数(默认通常为100,生产环境可调至200-500),再对应调整Spark的读并发数,避免超过上限。

2.2 写并发:别让Spark把Cassandra写挂

Spark写Cassandra时,默认逐条写入会导致连接频繁建立和断开,速度极慢,还会占用大量连接资源。调写并发的核心是增加批处理的数量,同时控制写的并发连接数,减少连接开销。 示例代码(同一技术栈):

// Spark写入Cassandra的写并发调优示例
import org.apache.spark.sql.SparkSession

object CassandraWriteTuning {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder()
      .appName("SparkCassandraWriteTuning")
      // 每批写入的行数,设为1000,减少连接建立次数
      .config("spark.cassandra.output.batch.size.rows", "1000")
      // 单个Spark executor的写并发数,通常比读并发高,写需更多连接处理批量数据,设为16左右
      .config("spark.cassandra.concurrent.writes", "16")
      // 一致性级别设为ONE,分析场景无需强一致,可大幅降低写等待时间
      .config("spark.cassandra.output.consistency.level", "ONE")
      .master("local[*]")
      .getOrCreate()

    // 模拟生成用户行为数据,实际可替换为其他数据源(如HDFS、MySQL)
    val mockDF = spark.createDataFrame(Seq(
      ("2024-05-20", "user1", "click"),
      ("2024-05-20", "user2", "view"),
      ("2024-05-20", "user3", "buy")
    )).toDF("date", "user_id", "action")

    // 写入Cassandra,模式设为append,避免覆盖原有数据
    mockDF.write
      .format("org.apache.spark.sql.cassandra")
      .options(Map(
        "keyspace" -> "user_db",
        "table" -> "behavior"
      ))
      .mode("append")
      .save()

    spark.stop()
  }
}

应用场景:Spark定时将用户行为统计结果写入Cassandra,供前端查询,调写并发后,几GB数据的写入时间可从小时级缩短至分钟级。技术优缺点:优点是写吞吐量提升、时间缩短;缺点是批处理过大可能占用Spark executor过多内存,导致OOM。注意事项:根据executor内存调整batch.size,如4G内存的executor,batch.size建议不超过10000,避免内存溢出。

三、本地感知策略:省掉跨节点的“跑腿”时间

3.1 什么是本地感知?

简单说就是Spark的executor运行在哪个Cassandra节点所在的机器上,就优先连接本机的Cassandra节点,不用跨机架或跨机房传输数据,节省网络时间。好比你拿快递时,隔壁小区有快递就不用跑对面城市,能大幅降低数据传输的延迟。

3.2 怎么配置本地感知?

需先确认Cassandra的DC(数据中心)标识,Spark指定对应DC后,会自动优先连接同节点的Cassandra。示例代码:

// Spark开启本地感知的配置示例,同一技术栈
import org.apache.spark.sql.SparkSession

object LocalAwareTuning {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder()
      .appName("SparkCassandraLocalAware")
      // 指定Cassandra的本地DC,可通过Cassandra的system.local表查询,执行SELECT data_center FROM system.local;获取
      .config("spark.cassandra.connection.localDC", "dc1")
      // 开启本地感知,让Spark优先连接同节点的Cassandra
      .config("spark.cassandra.connection.localSync", "true")
      .master("local[*]")
      .getOrCreate()

    // 读取Cassandra数据,此时Spark会优先连同机器的Cassandra节点,延迟大幅降低
    val df = spark.read
      .format("org.apache.spark.sql.cassandra")
      .options(Map("keyspace" -> "user_db", "table" -> "behavior"))
      .load()

    df.show()
    spark.stop()
  }
}

应用场景:多机房部署的集群,Spark任务跑在us-east-1机房,开启本地感知后,读同机房的Cassandra,延迟从数百毫秒降至数十毫秒。技术优缺点:优点是延迟降低、节省跨机房带宽;缺点是DC配置错误会导致连接失败或连到错误节点。注意事项:必须准确查询Cassandra的DC名,不能手动随便写,否则本地感知失效。

四、资源隔离实践:别让分析任务抢了Cassandra的资源

4.1 为什么要资源隔离?

Spark的分析任务和Cassandra的服务任务都需要占用CPU、内存、连接数等资源,如果Spark任务过度占用资源,会导致Cassandra本身的读写被卡住,甚至崩溃。比如线上凌晨跑Spark分析任务,白天用户查询变慢,就是因为没做资源隔离。

4.2 怎么实现资源隔离?

核心是给Spark和Cassandra分配各自的资源上限,避免互相抢占。先配置Cassandra节点的资源,再限制Spark连接Cassandra的最大资源:

# Cassandra节点的资源配置,写入cassandra.yaml,适合8核16G的节点
concurrent_reads: 32 # 每个节点的读并发数,一半给业务查询,一半给Spark分析
concurrent_writes: 32 # 写并发数同理,预留资源给Cassandra本身
max_connections_per_host: 64 # 每个host的最大连接数,Spark最多用30个,剩下的给业务

Spark端的配置示例:

// Spark端的资源隔离配置,同一技术栈
val spark = SparkSession.builder()
  .appName("ResourceIsolationExample")
  // 限制Spark连Cassandra的最大连接数,不超过Cassandra的64上限,避免过载
  .config("spark.cassandra.connection.maxConnections", "30")
  // 每个executor用4核,留2核给Cassandra系统进程,避免CPU被占满
  .config("spark.executor.cores", "4")
  // 每个executor用8G内存,剩下8G给Cassandra,避免内存不足
  .config("spark.executor.memory", "8g")
  .master("yarn") // 生产环境用YARN集群,资源分配更灵活
  .getOrCreate()

应用场景:线上混合部署,Cassandra和Spark在同一节点,资源隔离后,Spark跑分析任务时,最多占30个连接,剩下的连接给前端业务查询,不影响正常服务。技术优缺点:优点是系统稳定性大幅提升,不会因分析任务导致业务中断;缺点是资源利用率略低,因为预留了部分资源,适合对稳定性要求高的场景。注意事项:根据节点配置精准计算预留资源,比如8核16G的节点,Cassandra系统进程需留2核4G,Spark用剩下的6核12G,平衡两者的资源需求。

五、总结

Spark连接Cassandra的调优核心是三个方向:读写并发匹配Cassandra的承载能力,避免节点过载;开启本地感知节省跨节点的网络延迟;做好资源隔离,保障Cassandra本身的服务稳定性。这些调优不是一次性的,需结合集群规模、Cassandra配置、Spark任务类型调整,小流量测试后再上线生产环境,避免影响业务。