Flink实战-（5）Flink Kafka实时Error日志告警

已于 2023-04-20 11:20:57 修改
阅读量902 收藏 4
点赞数
分类专栏： 大数据 文章标签： kafka flink java
于 2022-06-22 00:01:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carson073/article/details/125400447
版权

1 环境准备

1.1 新建日志Topic

1.2 项目结构

2 代码设计

Maven配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>flink-kafka-log</artifactId>
    <version>2.0-SNAPSHOT</version>

    <properties>
        <flink.version>1.13.6</flink.version>
        <scala.binary.version>2.11</scala.binary.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-runtime-web_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.ververica</groupId>
            <artifactId>flink-connector-mysql-cdc</artifactId>
            <version>1.4.0</version>
        </dependency>
        <!--        <dependency>-->
        <!--            <groupId>mysql</groupId>-->
        <!--            <artifactId>mysql-connector-java</artifactId>-->
        <!--            <version>5.1.47</version>-->
        <!--            <scope>provided</scope>-->
        <!--        </dependency>-->
        <!--        <dependency>-->
        <!--            <groupId>org.postgresql</groupId>-->
        <!--            <artifactId>postgresql</artifactId>-->
        <!--            <version>42.2.23</version>-->
        <!--        </dependency>-->
        <!--        <dependency>-->
        <!--            <groupId>org.apache.flink</groupId>-->
        <!--            <artifactId>flink-table-planner-blink_2.12</artifactId>-->
        <!--            <version>${flink-version}</version>-->
        <!--        </dependency>-->
        <!--<dependency>
            <groupId>com.ververica</groupId>
            <artifactId>flink-connector-mysql-cdc</artifactId>
            <version>2.0.2</version>
        </dependency>-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>

                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <!--如果要打包的话，这里要换成对应的 main class-->
                                    <mainClass>com.flink.log.LogEventAlert</mainClass>
                                </transformer>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>reference.conf</resource>
                                </transformer>
                            </transformers>
                            <filters>
                                <filter>
                                    <artifact>*:*:*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

application.properties配置

kafka.brokers=master1:9092
kafka.group.id=zhisheng
kafka.zookeeper.connect=master1:2181
metrics.topic=zhisheng_metrics
log.topic=zhisheng_log
stream.parallelism=4
stream.checkpoint.interval=1000
stream.checkpoint.enable=false

2.1 工具类

package com.flink.log;

import org.apache.flink.api.common.restartstrategy.RestartStrategies;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.io.IOException;


public class ExecutionEnvUtil {
    public static ParameterTool createParameterTool(final String[] args) throws Exception {
        return ParameterTool
                .fromPropertiesFile(com.flink.log.ExecutionEnvUtil.class.getResourceAsStream(PropertiesConstants.PROPERTIES_FILE_NAME))
                .mergeWith(ParameterTool.fromArgs(args))
                .mergeWith(ParameterTool.fromSystemProperties());
    }

    public static final ParameterTool PARAMETER_TOOL = createParameterTool();

    private static ParameterTool createParameterTool() {
        try {
            return ParameterTool
                    .fromPropertiesFile(com.flink.log.ExecutionEnvUtil.class.getResourceAsStream(PropertiesConstants.PROPERTIES_FILE_NAME))
                    .mergeWith(ParameterTool.fromSystemProperties());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ParameterTool.fromSystemProperties();
    }

    public static StreamExecutionEnvironment prepare(ParameterTool parameterTool) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(parameterTool.getInt(PropertiesConstants.STREAM_PARALLELISM, 5));
        env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(4, 60000));
        if (parameterTool.getBoolean(PropertiesConstants.STREAM_CHECKPOINT_ENABLE, true)) {
            env.enableCheckpointing(parameterTool.getLong(PropertiesConstants.STREAM_CHECKPOINT_INTERVAL, 10000));
        }
        env.getConfig().setGlobalJobParameters(parameterTool);
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        return env;
    }
}
package com.flink.log;

import com.google.gson.Gson;

import java.nio.charset.Charset;


public class GsonUtil {
    private final static Gson gson = new Gson();

    public static <T> T fromJson(String value, Class<T> type) {
        return gson.fromJson(value, type);
    }

    public static String toJson(Object value) {
        return gson.toJson(value);
    }

    public static byte[] toJSONBytes(Object value) {
        return gson.toJson(value).getBytes(Charset.forName("UTF-8"));
    }
}

package com.flink.log;

import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.internals.KafkaTopicPartition;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndTimestamp;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.TopicPartition;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import static com.flink.log.PropertiesConstants.*;



public class KafkaConfigUtil {

    /**
     * 设置基础的 Kafka 配置
     *
     * @return
     */
    public static Properties buildKafkaProps() {
        return buildKafkaProps(ParameterTool.fromSystemProperties());
    }

    /**
     * 设置 kafka 配置
     *
     * @param parameterTool
     * @return
     */
    public static Properties buildKafkaProps(ParameterTool parameterTool) {
        Properties props = parameterTool.getProperties();
        props.put("bootstrap.servers", parameterTool.get(PropertiesConstants.KAFKA_BROKERS, DEFAULT_KAFKA_BROKERS));
        props.put("zookeeper.connect", parameterTool.get(PropertiesConstants.KAFKA_ZOOKEEPER_CONNECT, DEFAULT_KAFKA_ZOOKEEPER_CONNECT));
        props.put("group.id", parameterTool.get(PropertiesConstants.KAFKA_GROUP_ID, DEFAULT_KAFKA_GROUP_ID));
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("auto.offset.reset", "latest");
        return props;
    }


    public static DataStreamSource<MetricEvent> buildSource(StreamExecutionEnvironment env) throws IllegalAccessException {
        ParameterTool parameter = (ParameterTool) env.getConfig().getGlobalJobParameters();
        String topic = parameter.getRequired(PropertiesConstants.METRICS_TOPIC);
        Long time = parameter.getLong(PropertiesConstants.CONSUMER_FROM_TIME, 0L);
        return buildSource(env, topic, time);
    }

    /**
     * @param env
     * @param topic
     * @param time  订阅的时间
     * @return
     * @throws IllegalAccessException
     */
    public static DataStreamSource<MetricEvent> buildSource(StreamExecutionEnvironment env, String topic, Long time) throws IllegalAccessException {
        ParameterTool parameterTool = (ParameterTool) env.getConfig().getGlobalJobParameters();
        Properties props = buildKafkaProps(parameterTool);
        FlinkKafkaConsumer<MetricEvent> consumer = new FlinkKafkaConsumer<>(
                topic,
                new MetricSchema(),
                props);
        //重置offset到time时刻
        if (time != 0L) {
            Map<KafkaTopicPartition, Long> partitionOffset = buildOffsetByTime(props, parameterTool, time);
            consumer.setStartFromSpecificOffsets(partitionOffset);
        }
        return env.addSource(consumer);
    }

    private static Map<KafkaTopicPartition, Long> buildOffsetByTime(Properties props, ParameterTool parameterTool, Long time) {
        props.setProperty("group.id", "query_time_" + time);
        KafkaConsumer consumer = new KafkaConsumer(props);
        List<PartitionInfo> partitionsFor = consumer.partitionsFor(parameterTool.getRequired(PropertiesConstants.METRICS_TOPIC));
        Map<TopicPartition, Long> partitionInfoLongMap = new HashMap<>();
        for (PartitionInfo partitionInfo : partitionsFor) {
            partitionInfoLongMap.put(new TopicPartition(partitionInfo.topic(), partitionInfo.partition()), time);
        }
        Map<TopicPartition, OffsetAndTimestamp> offsetResult = consumer.offsetsForTimes(partitionInfoLongMap);
        Map<KafkaTopicPartition, Long> partitionOffset = new HashMap<>();
        offsetResult.forEach((key, value) -> partitionOffset.put(new KafkaTopicPartition(key.topic(), key.partition()), value.offset()));

        consumer.close();
        return partitionOffset;
    }
}

package com.flink.log;


public class PropertiesConstants {
    public static final String KAFKA_BROKERS = "kafka.brokers";
    public static final String DEFAULT_KAFKA_BROKERS = "localhost:9092";
    public static final String KAFKA_ZOOKEEPER_CONNECT = "kafka.zookeeper.connect";
    public static final String DEFAULT_KAFKA_ZOOKEEPER_CONNECT = "localhost:2181";
    public static final String KAFKA_GROUP_ID = "kafka.group.id";
    public static final String DEFAULT_KAFKA_GROUP_ID = "zhisheng";
    public static final String METRICS_TOPIC = "metrics.topic";
    public static final String CONSUMER_FROM_TIME = "consumer.from.time";
    public static final String STREAM_PARALLELISM = "stream.parallelism";
    public static final String STREAM_CHECKPOINT_ENABLE = "stream.checkpoint.enable";
    public static final String STREAM_CHECKPOINT_INTERVAL = "stream.checkpoint.interval";
    public static final String PROPERTIES_FILE_NAME = "/application.properties";
}

2.2 反序列化类

package com.flink.log;

import com.google.gson.Gson;
import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.serialization.SerializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;

import java.io.IOException;
import java.nio.charset.Charset;


public class LogSchema implements DeserializationSchema<LogEvent>, SerializationSchema<LogEvent> {

    private static final Gson gson = new Gson();

    @Override
    public LogEvent deserialize(byte[] bytes) throws IOException {
        return gson.fromJson(new String(bytes), LogEvent.class);
    }

    @Override
    public boolean isEndOfStream(LogEvent logEvent) {
        return false;
    }

    @Override
    public byte[] serialize(LogEvent logEvent) {
        return gson.toJson(logEvent).getBytes(Charset.forName("UTF-8"));
    }

    @Override
    public TypeInformation<LogEvent> getProducedType() {
        return TypeInformation.of(LogEvent.class);
    }
}

package com.flink.log;

import com.google.gson.Gson;
import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.serialization.SerializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;

import java.io.IOException;
import java.nio.charset.Charset;


public class MetricSchema implements DeserializationSchema<MetricEvent>, SerializationSchema<MetricEvent> {

    private static final Gson gson = new Gson();

    @Override
    public MetricEvent deserialize(byte[] bytes) throws IOException {
        return gson.fromJson(new String(bytes), MetricEvent.class);
    }

    @Override
    public boolean isEndOfStream(MetricEvent metricEvent) {
        return false;
    }

    @Override
    public byte[] serialize(MetricEvent metricEvent) {
        return gson.toJson(metricEvent).getBytes(Charset.forName("UTF-8"));
    }

    @Override
    public TypeInformation<MetricEvent> getProducedType() {
        return TypeInformation.of(MetricEvent.class);
    }
}

2.3 日志结构设计

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class LogEvent {
    //日志的类型(应用、容器、...)
    private String type;

    //日志的时间戳
    private Long timestamp;

    //日志的级别(debug/info/warn/error)
    private String level;

    //日志内容
    private String message;

    //日志的标识(应用 ID、应用名、容器 ID、机器 IP、集群名、...)
    private Map<String, String> tags = new HashMap<>();
}

样例数据：

{
    "type": "app",
    "timestamp": 1570941591229,
    "level": "error",
    "message": "Exception in thread \"main\" java.lang.NoClassDefFoundError: org/apache/flink/api/common/ExecutionConfig$GlobalJobParameters",
    "tags": {
        "cluster_name": "zhisheng",
        "app_name": "zhisheng",
        "host_ip": "127.0.0.1",
        "app_id": "21"
    }
}
package com.flink.log;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Map;


@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MetricEvent {

	/**
	 * Metric name
	 */
	private String name;

	/**
	 * Metric timestamp
	 */
	private Long timestamp;

	/**
	 * Metric fields
	 */
	private Map<String, Object> fields;

	/**
	 * Metric tags
	 */
	private Map<String, String> tags;
}

2.4 主类

package com.flink.log;

import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

import java.util.Properties;


public class LogEventAlert {
    public static void main(String[] args) throws Exception {
        final ParameterTool parameterTool = ExecutionEnvUtil.createParameterTool(args);
        StreamExecutionEnvironment env = ExecutionEnvUtil.prepare(parameterTool);

        Properties properties = KafkaConfigUtil.buildKafkaProps(parameterTool);
        FlinkKafkaConsumer<LogEvent> consumer = new FlinkKafkaConsumer<>(
                parameterTool.get("log.topic"),
                new LogSchema(),
                properties);
        env.addSource(consumer)
                .filter(logEvent -> "error".equals(logEvent.getLevel()))
                .print();
        env.execute("log event alert");
    }
}

2.5 模拟日志生成类

import com.flink.log.GsonUtil;
import com.flink.log.LogEvent;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Random;

public class BuildLogEventDataUtil {
    public static final String BROKER_LIST = "master1:9092";
    public static final String LOG_TOPIC = "zhisheng_log";

    public static void writeDataToKafka() {
        Properties props = new Properties();
        props.put("bootstrap.servers", BROKER_LIST);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer producer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            LogEvent logEvent = new LogEvent().builder()
                    .type("app")
                    .timestamp(System.currentTimeMillis())
                    .level(logLevel())
                    .message(message(i + 1))
                    .tags(mapData())
                    .build();
            System.out.println(logEvent);
            ProducerRecord record = new ProducerRecord<String, String>(LOG_TOPIC, null, null, GsonUtil.toJson(logEvent));
            producer.send(record);
        }
        producer.flush();
    }

    public static void main(String[] args) {
        writeDataToKafka();
    }

    public static String message(int i) {
        return "这是第 " + i + " 行日志！";
    }

    public static String logLevel() {
        Random random = new Random();
        int number = random.nextInt(4);
        switch (number) {
            case 0:
                return "debug";
            case 1:
                return "info";
            case 2:
                return "warn";
            case 3:
                return "error";
            default:
                return "info";
        }
    }

    public static String hostIp() {
        Random random = new Random();
        int number = random.nextInt(4);
        switch (number) {
            case 0:
                return "121.12.17.10";
            case 1:
                return "121.12.17.11";
            case 2:
                return "121.12.17.12";
            case 3:
                return "121.12.17.13";
            default:
                return "121.12.17.10";
        }
    }

    public static Map<String, String> mapData() {
        Map<String, String> map = new HashMap<>();
        map.put("app_id", "11");
        map.put("app_name", "zhisheng");
        map.put("cluster_name", "zhisheng");
        map.put("host_ip", hostIp());
        map.put("class", "BuildLogEventDataUtil");
        map.put("method", "main");
        map.put("line", String.valueOf(new Random().nextInt(100)));
        //add more tag
        return map;
    }
}

3 本地运行

 运行成功！

4 打包发布

CarsonBigData
关注
专栏目录
基于 Apache Flink 的实时监控告警系统
http://www.54tianzhisheng.cn/
04-16 7737
点击上方“zhisheng”，选择“设为星标”后台回复”666“获取公众号专属资料本文首发自本人的知识星球《Flink 精进学习》，文末点击阅读原文可以查看对应讲解的视频在如今微服务、云...
flink实战--如何基于java-agent技术增强Flink功能
阿华田的博客
09-13 347
一个Flink程序的运行，会依赖到一个或多个Connector（连接器），而这些连接器分为Source（主要用于读）和Sink（主要用于写），那么如果要监听到Flink作业流动的数据，我们这里可以简单尝试去查看支持Sink的Connector(例如：flink-connector-jdbc)，看看 是否有实现一个公共的接口，然后对这个接口做监听，即可“读取”写入前的数据?接下来可以开始编写一个Agent类了，这里直接上代码。
kafka无法启动，生成hs_err_pid****.log日志
m0_47135938的博客
02-13 362
kafka启动失败，出现hs_err_pid10266.log之类的日志，前往bin目录，修改启动脚本的参数
基于Flink+kafka实时告警
huangpf_vcx
01-16 1963
某项目使用告警系统的逻辑是将实时数据保存到本地数据库再使用定时任务做判断，然后产生告警数据。这种方式存在告警的延时实在是太高了。数据从产生到保存，从保存到判断都会存在时间差，按照保存数据定时5分钟一次，定时任务5分钟一次。最高会产生10分钟的误差，这种告警就没什么意义了。
Flink+Kafka：构建日志采集+流式处理分析日志
jdk819的博客
11-04 977
Flink和Kafka的配合难点在于版本的适配，本文提供已适配版本，并且提供docker镜像、docker启动脚本以及k8s多副本部署Flink和Kafka的部署脚本。 一、版本选择 Flink：1.10.0-scala_2.12 Kafka：2.12-2.3.1 wurstmeister/zookeeper：3.4.6 版本资源、docker部署脚本以及k8s多副本方式部署脚本（包含k8s各个pod之间的动态通信脚本...
轻松通关Flink第38讲：Flink 调用 CEP 实现报警功能
sucaiwa的博客
03-29 666
这一课时我们分别对连续登录、交易活跃用户、超时未支付三种业务场景进行了完整的代码实现，我们实际业务场景中可以根据本节课的内容灵活处理。
Flink-SQL upset-Kafka自定义分区器
qq_39639186的博客
12-13 2649
Flink-SQL upset-Kafka自定义分区器
flink实战 -- flink SQL 实现列转行
最新发布
阿华田的博客
11-11 310
WITH ('connector' = 'kafka', -- 使用 kafka connector'properties.bootstrap.servers' = 'master:9092,storm1:9092,storm2:9092', -- broker连接信息'properties.group.id' = 'jason_flink_test', -- 消费kafka的group_id'scan.startup.mode' = 'latest-offset', -- 读取数据的位置。
Flink CDC 与 Kafka 集成：Snapshot 还是 Changelog？Upsert Kafka 还是 Kafka？
Laurence的技术博客
02-05 1497
我们知道，尽管 Flink CDC 可以越过 Kafka，将关系型数据库中的数据表直接“映射”成数据湖上的一张表（例如 Hudi 等）， 但从整体架构上考虑，维护一个 Kafka 集群作为数据接入的统一管道是非常必要的，这会带来很多收益。在 Flink CDC 之前，以 Debezium + Kafka Connect 为代表的技术组合都是将数据库的CDC数据先接入到 Kafka 中，然后再由后续的组件解析和处理。
Flink 源码解析 Flink-Connector (Kafka)
文报的博客
12-23 1433
flink版本:<flink.version>1.10.0</flink.version>FlinkKafkaConsumerBase: 所有Flink Kafka Consumer数据源的基类。这个类实现了所有Kafka版本的公共行为 open方法 @Override public void open(Configuration configuration) throws Exception { // determine the offset commit mode
基于Flink的实时告警实现(1)：Flink简介与开发环境搭建
追寻梦想的青春
03-23 1124
本专题将会从0到1实现告警处理流程，并会讲解实现过程中使用到的Flink中的技术。 1 Flink简介 Flink是一个流式的分布式处理引擎，可以同时处理有界流和无界流，并可以运行在常见的集群环境中。 Flink常用的应用场景有： (1) 事件驱动型应用 (2) 数据分析型应用 (3) 数据管道应用：将数据进行转换后再迁移到其他的存储系统 2 Flink的Local部署模式 Flink支持三种部署模式： Local：本地直接起一个taskmanager，通常用于本地调试 Standalone：物理机集.
Flink 1.14.0 消费kafka数据报warn日志
她从小就是校花的博客
01-08 665
flink 消费kafka数据报warn日志
Flink异常：TaskExecutor中不存在LOG文件的问题解决
2301_79366177的博客
08-12 1073
通过分析和解决方案，我们可以应对Flink异常“TaskExecutor中不存在LOG文件”的问题。根据具体情况检查配置文件、存储设备空间，并尝试重新生成日志文件，可以解决大部分相关的问题。如果日志文件被人为删除或者损坏，TaskExecutor将无法找到对应的文件。确保日志目录的路径是正确的，并且具有足够的权限让TaskExecutor可以访问和写入日志文件。如果日志目录所在的存储设备空间不足，可能会导致TaskExecutor无法正常写入日志文件。在重新启动之前，可以先备份原有的日志文件以便后续分析。
Flink Logback日志与邮件报警配置
LittleMagic's Blog
03-04 1526
短文模式继续。 Flink官方推荐使用Logback替代默认的Log4j作为日志框架。我们之前一直用Log4j，最近切换成了更优秀的Logback，但是配置起来略有点麻烦，本文简述配置过程。 在项目POM中加入Logback的依赖项：logback-core、logback-classic，以及log4j-over-slf4j（因为Flink依赖于Hadoop，Hadoop却直接...
Flink SQL 实时读取 kafka 数据写入 Clickhouse —— 日志处理（三）
奔跑的蜗牛的博客
07-21 2050
本文总结了如何使用使用 Clickhouse 保存日志数据，以及如何通过 Flink SQL 将我们的日志实时从 kafka 同步至 clickhouse，然后在结合强大的第三方查询 BI 工具 superset，玩转业务日志，挖掘业务日志的潜在价值。 本文设计到的技能知识点比较多，需要熟悉 Clickhouse， Kafka, FlinkSQL, Superset 等，我之前的文章中总结了一些关于 Clickhouse 和 Kafka 相关的内容，感兴趣的读者可以看看.
Flink kafka connectors 源码详解---＜2＞
adddimin的博客
01-07 396
方法，该方法凸出的功能，1.初始化记录当前split的offset，2.ck时，将split、offset 信息作为state保存，3.在KafkaRecordEmitter emit record时，动态更新 offset 信息，保证source 源头，消费的一致性。先了解 SplitFetcherManager，如果去源码的英文注解就可以很明显的知道，它就是要维持一个线程池，同时保存好所有的splitFetcher，splitFetcher，既有run方法，也可以提交任务。有意思的可以去看源码。
PyFlink UDF 实时日志监控告警实现
02-21
本实例主要探讨如何利用 PyFlink（Flink 的 Python API）结合自定义用户定义函数（User Defined Function，UDF）来实现实时日志监控告警系统。这个系统能够及时解析系统产生的日志数据，并根据预设条件触发告警，...
Flink的实时监控和警报系统
AI天才研究院
01-18 1797
1.背景介绍 Flink是一个流处理框架，用于处理大规模数据流。它提供了实时计算和流处理功能，可以用于实时分析和监控。在大数据场景中，Flink的实时监控和警报系统非常重要，可以帮助我们快速发现问题并采取措施。 Flink的实时监控和警报系统包括以下几个方面： 流处理任务的监控：包括任务的执行状态、性能指标、错误日志等。 数据流的监控：包括数据流的速度、数据量、数据质量等。 警报系统：包括...
基于Flink的实时告警实现(2)：读取数据源
追寻梦想的青春
03-23 940
本专题将会从0到1实现告警处理流程，并会讲解实现过程中使用到的Flink中的技术。 1 Flink的工作方式 使用Flink常用的方式是将Flink作为管道和管道之间的处理器，Flink从源中读取数据，进行逻辑计算后，将结果写入到目的，这里的源和目的可以是同一类系统，例如，都是kafka。Flink内置的和扩展的Connectors：https://ci.apache.org/projects/flink/flink-docs-stable/dev/connectors/。 Source -> Tra
Flink Kafka Producer报错:The producer has been rejected from the broker because it tried to use an old
Knight-ZXW的博客
07-07 2300
背景 在开发一个APM项目的过程中，需要使用flink从阿里云的sls消费数据并写入kafka，这里使用的Sink是flink官方支持库提供的 FlinkKafkaProducer ，对接后在运行过程中较频繁的出现以下异常 2021-07-07 11:25:56.080 [ERROR] [APM_ANRProcess -> Sink: APM_ANRSink (1/1)] [org.apache.flink.streaming.runtime.tasks.StreamTask][732] - Erro
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值