flink on yarn 任务监控脚本 flink监控api

转载

风华绝代的java 2024-01-28 00:35:19

文章标签 flink 大数据 scala apache 数据 文章分类 Yarn 大数据

本文主要从以下几个方面介绍Flink流处理API——State API (状态管理)

一、状态管理

Flink中的状态

A. 算子状态：
B. 键控状态（Keyed State）-- 更常用
C. 状态后端（State Backends） -- 状态管理（存储、访问、维护和检查点）

二、状态编程

版本：

scala：2.11.12

Kafka：0.8.2.2

Flink：1.7.2

<dependencies>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-scala_2.11</artifactId>
            <version>1.7.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_2.11</artifactId>
            <version>1.7.2</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.11</artifactId>
            <version>1.7.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-connector-kafka-0.10 -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka-0.8_2.11</artifactId>
            <version>1.7.2</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.22</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.22</version>
        </dependency>

        <dependency>
            <groupId>org.apache.bahir</groupId>
            <artifactId>flink-connector-redis_2.11</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>

一、状态管理

1、Flink中的状态

A. 算子状态（Operatior State）
B. 键控状态（Keyed State）
状态后端（State Backends） -- 用作状态管理

flink on yarn 任务监控脚本 flink监控api_apache

2、流式处理的数据一般就两种：

A. 可以是无状态（基于某个独立的事件计算出来后直接输出了，来一个处理一个不涉及到其他东西，如map、flatmap、filter；超过一定温度就报警 - 侧输出流；）

B. 可以是有状态的（求和、wordcount计算；判断两次数据是不是跃变）

状态是针对一个任务而言的，由一个任务维护，并且用来计算某个结果的所有数据，都属于这个任务的状态；
可以认为状态就是一个本地变量，可以被任务的业务逻辑直接访问；
Flink会进行状态管理（状态做序列化以二进制的形式全部存储起来），包括状态一致性、故障处理以及高效存储和访问，以便开发人员可以专注于应用程序的逻辑。

3、在Flink中，状态始终与特定算子相关联；为了运行时的Flink了解算子的状态，算子需要预先注册其状态；

有两种状态：

　　算子状态（Operator State），算子状态的作用范围限定为算子任务，一个任务一个状态；

　　键控（分区）状态（Keyed State），根据输入数据流中定义的键（Key）来维护和访问（基于KeyBy--KeyedStream上有任务出现的状态，定义的不同的key来维护这个状态；不同的key也是独立访问的，一个key只能访问它自己的状态，不同key之间也不能互相访问）；

A. 算子状态：

flink on yarn 任务监控脚本 flink监控api_数据_02

算子状态的作用范围限定为算子任务，由同一并行子任务所处理的所有数据都可以访问到相同的状态；

状态对于同一个任务而言是共享的（每一个并行的子任务共享一个状态）；

算子状态不能由相同或不同算子的另一个任务访问（相同算子的不同任务之间也不能访问）；

算子状态数据结构：

列表状态（List state），将状态表示为一组数据的列表；（会根据并行度的调整把之前的状态重新分组重新分配）

联合列表状态（Union list state），也将状态表示为数据的列表，它常规列表状态的区别在于，在发生故障时，或者从保存点（savepoint）启动应用程序时如何恢复（把之前的每一个状态广播到对应的每个算子中）。

广播状态（Broadcast state），如果一个算子有多项任务，而它的每项任务状态又都相同，那么这种特殊情况最适合应用广播状态（把同一个状态广播给所有算子子任务）；

B. 键控状态（Keyed State）-- 更常用

flink on yarn 任务监控脚本 flink监控api_数据_03

键控状态是根据输入数据流中定义的键（key）来维度和访问状态的；

Flink为每个key维护一个状态实例，并将具有相同键的所有数据，都分区到同一个算子任务中，这个任务会维护和处理这个key对应的状态；

当任务处理一条数据时，它会自动将状态的访问范围限定为当前数据的key；

键控状态数据结构：

ValueState[T]保存单个的值，值的类型为 T。值状态（Value state），将状态表示为单个值

get 操作: ValueState.value()

set 操作: ValueState.update(value: T)

ListState[T]保存一个列表，列表里的元素的数据类型为 T。列表状态（List state），将状态表示为一组数据的列表（存多个状态）

ListState.add(value: T)

ListState.addAll(values: java.util.List[T])

ListState.get()返回

Iterable[T] ListState.update(values: java.util.List[T])

MapState[K, V]保存 Key-Value 对。映射状态（Map state），将状态表示为一组Key-Value对

MapState.get(key: K)

MapState.put(key: K, value: V)

MapState.contains(key: K)

MapState.remove(key: K)

ReducingState[T] 聚合状态（Reducing state & Aggregating State），将状态表示为一个用于聚合操作的列表
AggregatingState[I, O]
Reduce输入输出类型是不能变的，Aggregate可得到数据类型完全不一样的结果；

键控状态的使用：

声明一个键控状态:
lazy val lastTemp: ValueState[Double] = getRuntimeContext.getState(
  new ValueStateDescriptor[Double]("lastTemp", classOf[Double])
)
读取状态:
val prevTemp = lastTemp.value()
对状态赋值:
lastTemp.update(value.temperature)

C. 状态后端（State Backends） -- 状态管理（存储、访问、维护和检查点）

每传入一条数据，有状态的算子任务都会读取和更新状态；

由于有效的状态访问对于处理数据的低效迟至关重要，因此每个并行任务都会在本地维度其状态，以确保快速的状态访问；

状态的存储、访问以及维度，由一个可插入的组件决定，这个组件就叫做状态后端（State Backends）；

状态后端主要负责两件事：本地的状态管理，以及将检查点（checkpoint）状态写入远程存储；

状态后端的分类：

MemoryStateBackend：一般用于开发和测试

内存级的状态后端，会将键控状态作为内存中的对象进行管理，将它们存储在TaskManager的JVM堆上，而将checkpoint存储在JobManager的内存中；
特点快速、低延迟，但不稳定；

FsStateBackend（文件系统状态后端）：生产环境

将checkpoint存到远程的持久化文件系统（FileSystem）上，而对于本地状态，跟MemoryStateBackend一样，也会存到TaskManager的JVM堆上。
同时拥有内存级的本地访问速度，和更好的容错保证；（如果是超大规模的需要保存还是无法解决，存到本地状态就可能OOM）

RocksDBStateBackend：

将所有状态序列化后，存入本地的RocksDB（本地数据库硬盘空间）中存储，全部序列化存储到本地。

二、状态编程

package xxx
import com.njupt.ymh.WindowAPITest.{MyAssigner, Myprocess, SensorReading}
import org.apache.flink.api.common.functions.{RichFlatMapFunction, RichFunction}
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.{KeyedProcessFunction, ProcessFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer08
import org.apache.flink.util.Collector

object StateTest {
  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    environment.setParallelism(1)  // 这里要设置并行度为1，才好把所有sensor_1的数据放在同一个window

    val inputStream = environment.socketTextStream("master", 7777)

    val keyed: KeyedStream[SensorReading, String] = inputStream.map(line => {
      val fildes: Array[String] = line.split(",") // 这里的split是scala的split方法
      val sensorReading = new SensorReading(fildes(0).trim, fildes(1).trim.toLong, fildes(2).trim.toDouble)
      println("input " + sensorReading)
      sensorReading
    }).keyBy(_.id)

  // 这里实现状态编程，实现当连续两次温度相差10度时进行报警业务逻辑

    environment.execute()
  }

}

一般有三种使用状态的方法：

1、通过调用底层ProcessFunction 的API进行访问状态，在底层API中可以访问到任何东西：

// 通过process实现
    val processed: DataStream[(String, Double, Double)] = keyed.process(new StateProcess(10.0))
    processed.print("10----").setParallelism(1)

/**
 * 温度跳变阈值输出报警信息
 * @param temp 温度差阈值
 */
class  StateProcess(temp: Double) extends  KeyedProcessFunction[String, SensorReading, (String, Double, Double)]{
  //  定义一个状态变量，用于报错上次的温度值
  lazy val lastTempState: ValueState[Double] = getRuntimeContext.getState[Double](new 
                  ValueStateDescriptor[Double]("lastTemp", classOf[Double]))

  override def processElement(i: SensorReading, context: KeyedProcessFunction[String, SensorReading, 
            (String, Double, Double)]#Context, collector: Collector[(String, Double, Double)]): Unit = {
    val lastTemp: Double = lastTempState.value()
    val dff = (lastTemp - i.temperature).abs

    if(dff > temp){
      collector.collect((i.id, lastTemp, i.temperature))
    }
    // 更改温度状态值
    lastTempState.update(i.temperature)
  }
}

2、在富函数中也可以使用状态

// 通过富函数实现
    val flatMaped: DataStream[(String, Double, Double)] = keyed.flatMap(new StateFunction(10.0))
    flatMaped.print("map____").setParallelism(1)

class StateFunction(temp: Double) extends RichFlatMapFunction[SensorReading, (String, Double, Double)] {
  var lastTempState: ValueState[Double] =_

  override def open(parameters: Configuration): Unit = {
    //  定义一个状态变量，用于报错上次的温度值
    lastTempState = getRuntimeContext.getState[Double](new 
                 ValueStateDescriptor[Double]("lastTemp", classOf[Double]))
  }

  override def flatMap(value: SensorReading, out: Collector[(String, Double, Double)]): Unit = {
    val lastTemp: Double = lastTempState.value()
    val dff = (lastTemp - value.temperature).abs

    if(dff > temp){
      out.collect((value.id, lastTemp, value.temperature))
    }
    // 更改温度状态值
    lastTempState.update(value.temperature)

  }
}

3、调用KeyedStream的flatMapWithState方法来实现

// 通过带状态的flatMap实现, [(String, Double, Double),Double] 输出类型， 状态类型.
    // 并且需要在参数中传递一个方法
    val flatMapWithStated: DataStream[(String, Double, Double)] = keyed.flatMapWithState[(String, Double, Double), Double]({
      // 如果没有状态，也就是没有数据来过，则将当前的数据保存为状态值
      case (input: SensorReading, None) => {
        (List.empty, Some(input.temperature))
      }
      // 如果有状态，则和当前数据进行比较，并将当前数据保存为状态值
      case (input: SensorReading, temp: Some[Double]) => {
        val diff: Double = (input.temperature - temp.get).abs
        if (diff > 10.0) {
          (List((input.id, temp.get, input.temperature)), Some(input.temperature))
        } else {
          (List.empty, Some(input.temperature))
        }
      }
    })

    flatMapWithStated.print("withStated").setParallelism(1)

其中flatMapWithState的源码如下：

// [R: TypeInformation, S: TypeInformation] R是输出类型， S是状态的类型
    def flatMapWithState[R: TypeInformation, S: TypeInformation](
      // Option[T] 是一个类型为 T 的可选值的容器： 
      // 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None。
      // 该方法要求传入数据流和状态，输出输出数据以及新的状态值
     fun: (T, Option[S]) => (TraversableOnce[R], Option[S])): DataStream[R] = {
       if (fun == null) {
         throw new NullPointerException("Flatmap function must not be null.")
       }

       val cleanFun = clean(fun)
       val stateTypeInfo: TypeInformation[S] = implicitly[TypeInformation[S]]
       val serializer: TypeSerializer[S] = stateTypeInfo.createSerializer(getExecutionConfig)

       val flatMapper = new RichFlatMapFunction[T, R] with StatefulFunction[T,TraversableOnce[R],S]{

         override val stateSerializer: TypeSerializer[S] = serializer

         override def flatMap(in: T, out: Collector[R]): Unit = {
           applyWithState(in, cleanFun) foreach out.collect
         }
      }
      flatMap(flatMapper)
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。