高速Hive查询引擎 – Impala

一、课前准备

安装好hive以及hadoop运行环境,并正常启动hadoop以及hive的

二、课堂主题

实现impala集群环境正常安装,并掌握impala的基本语法

三、课堂目标

熟练使用impala的语法

四、知识要点

离线任务处理流程概述

离线任务处理流程

由于大部分的软件框架,CDH都提供了压缩包的安装方式,但是由于impala有部分代码使用C++编写,所以impala在安装包的选择上面,cloudera公司没有提供tar包的安装方式,只提供了rpm的安装方式,我们可以通过下载rpm包来进行安装。注意:rpm包是linux操作系统上面的一种安装压缩包

1、 impala的概述

imala基本介绍

impala是cloudera提供的一款高效率的sql查询工具,提供实时的查询效果,官方测试性能比hive快10到100倍,其sql查询比sparkSQL还要更加快速,号称是当前大数据领域最快的查询sql工具,impala是参照谷歌的新三篇论文(Caffeine、Pregel、Dremel)当中的Dremel实现而来,其中旧三篇论文分别是(BigTable,GFS,MapReduce)分别对应我们即将学的HBase和已经学过的HDFS以及MapReduce

impala是基于hive并使用内存进行计算,兼顾数据仓库,具有实时,批处理,多并发等优点

impala与hive的关系

impala是基于hive的大数据分析查询引擎,直接使用hive的元数据库metadata,意味着impala元数据都存储在hive的metastore当中,并且impala兼容hive的绝大多数sql语法。所以需要安装impala的话,必须先安装hive,保证hive安装成功,并且还需要启动hive的metastore服务

impala的优点

1、impala比较快,非常快,特别快,因为所有的计算都可以放入内存当中进行完成,只要你内存足够大

2、摈弃了MR的计算,改用C++来实现,有针对性的硬件优化

3、具有数据仓库的特性,对hive的原有数据做数据分析

4、支持ODBC,jdbc远程访问

impala的缺点:

1、基于内存计算,对内存依赖性较大

2、改用C++编写,意味着维护难度增大

3、基于hive,与hive共存亡,紧耦合

4、稳定性不如hive,不存在数据丢失的情况

impala的架构以及查询计划

img

Impala的架构模块:

  • impala-server

    • 启动的守护进程,执行我们的查询计划 从节点,官方建议与所有的datanode装在一起,可以通过hadoop的短路读取特性实现数据的快速查询
  • impala-statestore

    • 状态存储区 主节点
  • impalas-catalog

    • 元数据管理区 主节点

查询执行

impalad分为frontend和backend两个层次, frondend用java实现(通过JNI嵌入impalad), 负责查询计划生成, 而backend用C++实现, 负责查询执行。

frontend**生成查询计划分为两个阶段:**

(1)生成单机查询计划,单机执行计划与关系数据库执行计划相同,所用查询优化方法也类似。

(2)生成分布式查询计划。 根据单机执行计划, 生成真正可执行的分布式执行计划,降低数据移动, 尽量把数据和计算放在一起。

![http://www.aboutyun.com/data/attachment/forum/201507/27/134940kb7luw6ix8in3w3s.png](https://imgs.delucia.cn/imgs/2021/clip_image004 - 副本.jpg)

上图是SQL查询例子, 该SQL的目标是在三表join的基础上算聚集, 并按照聚集列排序取topN。

impala的查询优化器支持代价模型: 利用表和分区的cardinality,每列的distinct值个数等统计数据, impala可估算执行计划代价, 并生成较优的执行计划。 上图左边是frontend查询优化器生成的单机查询计划, 与传统关系数据库不同, 单机查询计划不能直接执行, 必须转换成如图右半部分所示的分布式查询计划。 该分布式查询计划共分成6个segment(图中彩色无边框圆角矩形), 每个segment是可以被单台服务器独立执行的计划子树。

![img](https://imgs.delucia.cn/imgs/2021/clip_image006 - 副本.jpg)

2、impala的安装环境准备

需要提前安装好hadoop,hive,这两个框架,并且hive需要将hive的安装包,拷贝到所有的服务器上面都保存一份,因为impala需要引用hive的安装目录下面的一些依赖的jar包

3、下载impala的所有依赖包

由于impala没有提供tar包供我们进行安装,只提供了rpm包,所以我们在安装impala的时候,需要使用rpm包来进行安装,rpm包只有cloudera公司提供了,所以我们去cloudera公司网站进行下载rpm包即可,但是另外一个问题,impala的rpm包依赖非常多的其他的rpm包,可以一个个的将依赖找出来,也可以将所有的rpm包下载下来,制作成我们本地yum源来进行安装。我们这里就选择制作我们本地的yum源来进行安装,所以首先我们需要下载到所有的rpm包,下载地址如下

http://archive.cloudera.com/cdh5/repo-as-tarball/5.14.2/cdh5.14.2-centos7.tar.gz

下载好了之后,保留下,留作备用

将我们下载好的压缩包,上传到node03服务器的/kkb/soft路径下,并进行解压

cd /kkb/soft
tar -zxvf cdh5.14.2-centos7.tar.gz

4、制作本地yum源

镜像源是centos当中下载相关软件的地址,我们可以通过制作我们自己的镜像源指定我们去哪里下载impala的rpm包,这里我们使用httpd这个软件来作为服务端,启动httpd的服务来作为我们镜像源的下载地址

这里我们选用第三台机器作为镜像源的服务端

node03机器上执行以下命令

sudo yum  -y install httpd
sudo service httpd start

cd /etc/yum.repos.d
sudo vim localimp.repo 

[localimp]
name=localimp
baseurl=http://node03/cdh5.14.2/
gpgcheck=0
enabled=1

创建apache httpd的读取链接

sudo ln -s /kkb/soft/cdh/5.14.2 /var/www/html/cdh5.14.2

页面访问本地yum源,出现这个界面表示本地yum源制作成功

http://node03/cdh5.14.2

如果能够正常访问到文件浏览页面,证明我们的本地yum源安装成功

将制作好的localimp配置文件发放到所有需要安装impala的节点上去

node03执行以下命令进行分发
cd /etc/yum.repos.d/

sudo scp localimp.repo  node02:$PWD
sudo scp localimp.repo  node01:$PWD

5、开始安装impala

安装规划

服务名称 node01 node02 node03
impala-catalog 不安装 不安装 安装
impala-state-store 不安装 不安装 安装
impala-server 安装 安装 安装
#主节点node03执行以下命令进行安装

sudo yum  install  impala -y
impala-server
impala-state-store
impala-catalog
impala-shell

#从节点node01与node02安装以下服务
sudo yum install impala-server -y

6、所有节点配置impala

第一步:修改hive-site.xml

node03机器修改hive-site.xml内容如下

hive-site.xml配置

vim /kkb/install/hive-1.1.0-cdh5.14.2/conf/hive-site.xml
添加以下三个配置属性

<property>
    <name>hive.server2.thrift.bind.host</name>
    <value>node03.hadoop.com</value>
</property>
 <property>
     <name>hive.metastore.uris</name>
     <value>thrift://node03.kaikeba.com:9083</value>
 </property>
<property>
    <name>hive.metastore.client.socket.timeout</name>
    <value>3600</value>
 </property>

第二步:将hive的安装包发送到node02与node01机器上

在node03机器上面执行

cd /kkb/install/

scp -r hive-1.1.0-cdh5.14.2/ node02:$PWD
scp -r hive-1.1.0-cdh5.14.2/ node01:$PWD

第三步:node03启动hive的metastore服务

启动hive的metastore服务

node03机器启动hive的metastore服务

cd  /kkb/install/hive-1.1.0-cdh5.14.2

nohup bin/hive --service metastore &
nohup bin/hive -- service hiveserver2 &

注意:一定要保证mysql的服务正常启动,否则metastore的服务不能够启动

第四步:所有hadoop节点修改hdfs-site.xml添加以下内容

所有节点创建文件夹

sudo mkdir -p /var/run/hdfs-sockets

修改所有节点的hdfs-site.xml添加以下配置,修改完之后重启hdfs集群生效

vim  /kkb/install/hadoop-2.6.0-cdh5.14.2/etc/hadoop/hdfs-site.xml

<property>
    <name>dfs.client.read.shortcircuit</name>
    <value>true</value>
</property>

<property>
     <name>dfs.domain.socket.path</name>
     <value>/var/run/hdfs-sockets/dn</value>
</property>

<property>
    <name>dfs.client.file-block-storage-locations.timeout.millis</name>
    <value>10000</value>
</property>
<property>
     <name>dfs.datanode.hdfs-blocks-metadata.enabled</name>
     <value>true</value>
</property>

三台机器执行以下命令给文件夹授权

sudo  chown  -R  hadoop:hadoop   /var/run/hdfs-sockets/

第五步:重启hdfs

重启hdfs文件系统

node01服务器上面执行以下命令

cd /kkb/install/hadoop-2.6.0-cdh5.14.2/

sbin/stop-dfs.sh
sbin/start-dfs.sh

第六步:创建hadoop与hive的配置文件的连接

impala的配置目录为 /etc/impala/conf

这个路径下面需要把core-site.xmlhdfs-site.xml以及hive-site.xml拷贝到这里来,但是我们这里使用软连接的方式会更好

所有节点执行以下命令创建链接到impala配置目录下来

sudo ln -s /kkb/install/hadoop-2.6.0-cdh5.14.2/etc/hadoop/core-site.xml /etc/impala/conf/core-site.xml

sudo ln -s /kkb/install/hadoop-2.6.0-cdh5.14.2/etc/hadoop/hdfs-site.xml /etc/impala/conf/hdfs-site.xml

sudo ln -s /kkb/install/hive-1.1.0-cdh5.14.2/conf/hive-site.xml /etc/impala/conf/hive-site.xml

第七步:修改impala的配置文件

所有节点修改impala默认配置

所有节点更改impala默认配置文件以及添加mysql的连接驱动包

sudo vim /etc/default/impala

IMPALA_CATALOG_SERVICE_HOST=node03
IMPALA_STATE_STORE_HOST=node03

所有节点创建mysql的驱动包的软连接

sudo mkdir -p /usr/share/java
sudo ln -s /kkb/install/hive-1.1.0-cdh5.14.2/lib/mysql-connector-java-5.1.38.jar /usr/share/java/mysql-connector-java.jar
所有节点修改bigtop的java路径

修改bigtop的java_home路径

sudo vim /etc/default/bigtop-utils

export JAVA_HOME=/kkb/install/jdk1.8.0_141

第八步:启动impala服务

启动impala服务

主节点node03启动以下三个服务进程

sudo service impala-state-store start
sudo service impala-catalog start
sudo service impala-server start

从节点启动node01与node02启动impala-server

sudo service  impala-server  start

三台机器可以通过以下命令,查看impala进程是否存在

ps -ef | grep impala

注意:启动之后所有关于impala的日志默认都在/var/log/impala 这个路径下,node03机器上面应该有三个进程,node02与node01机器上面只有一个进程,如果进程个数不对,去对应目录下查看报错日志

浏览器页面访问:

访问impalad的管理界面

http://node03:25000/

访问statestored的管理界面

http://node03:25010/

访问catalog的管理界面

http://node03:25020

7、impala的使用

执行impala-shell即可进入交互界面

$ impala-shell

Starting Impala Shell without Kerberos authentication
Connected to node03:21000
Server version: impalad version 2.11.0-cdh5.14.2 RELEASE (build ed85dce709da9557aeb28be89e8044947708876c)
**********************************************************************
Welcome to the Impala shell.
(Impala Shell v2.11.0-cdh5.14.2 (ed85dce) built on Tue Mar 27 13:39:48 PDT 2018)
You can run a single query from the command line using the '-q' option.
**********************************************************************
[node03:21000] >

exit;退出交互界面

1、impala-shell语法

1.1、impala-shell的外部命令参数语法

不需要进入到impala-shell交互命令行当中即可执行的命令参数

impala-shell后面执行的时候可以带很多参数:

-h 查看帮助文档

impala-shell -h

-r 刷新整个元数据,数据量大的时候,比较消耗服务器性能

impala-shell -r

-v 查看对应版本

impala-shell -v -V

-f 执行查询文件

cd /kkb/install

vim impala-shell.sql

select * from course.score;

通过-f 参数来执行执行的查询文件

impala-shell -f impala-shell.sql

-p 显示查询计划

impala-shell -f impala-shell.sql -p

9.1.2、impala-shell的内部命令行参数语法

进入impala-shell命令行之后可以执行的语法

help命令

帮助文档

connect命令

connect hostname 连接到某一台机器上面去执行

refresh 命令

refresh dbname.tablename 增量刷新,刷新某一张表的元数据,主要用于刷新hive当中数据表里面的数据改变的情况

refresh course.score;

invalidate metadata 命令:

invalidate  metadata
全量刷新,性能消耗较大,主要用于hive当中新建数据库或者数据库表的时候来进行刷新

explain 命令:

用于查看sql语句的执行计划

explain select * from course.score;

explain的值可以设置成0,1,2,3等几个值,其中3级别是最高的,可以打印出最全的信息

set explain_level=3;

profile命令:

执行sql语句之后执行,可以打印出更加详细的执行步骤,

主要用于查询结果的查看,集群的调优等

select * from course.score;

profile;

注意:在hive窗口当中插入的数据或者新建的数据库或者数据库表,在impala当中是不可直接查询到的,需要刷新数据库,在impala-shell当中插入的数据,在impala当中是可以直接查询到的,不需要刷新数据库,其中使用的就是catalog这个服务的功能实现的,catalog是impala1.2版本之后增加的模块功能,主要作用就是同步impala之间的元数据

2、创建数据库

impala-shell进入到impala的交互窗口

2.1、查看所有数据库

show databases;

2.2、创建与删除数据库

创建数据库

CREATE DATABASE IF NOT EXISTS mydb1;
drop database  if exists  mydb;

创建数据库表并指定数据库表数据存放hdfs的位置(与hive建表语法类似)

hdfs dfs -mkdir -p /input/impala

create  external table  t3(id int ,name string ,age int )  row  format  delimited fields terminated  by  '\t' location  '/input/impala/external';

3、 创建数据库表

创建student表

CREATE TABLE IF NOT EXISTS mydb1.student (name STRING, age INT, contact INT );

创建employ表

create table employee (Id INT, name STRING, age INT,address STRING, salary BIGINT);
3.1、 数据库表中插入数据
insert into employee (ID,NAME,AGE,ADDRESS,SALARY)VALUES (1, 'Ramesh', 32, 'Ahmedabad', 20000 );
insert into employee values (2, 'Khilan', 25, 'Delhi', 15000 );
Insert into employee values (3, 'kaushik', 23, 'Kota', 30000 );
Insert into employee values (4, 'Chaitali', 25, 'Mumbai', 35000 );
Insert into employee values (5, 'Hardik', 27, 'Bhopal', 40000 );
Insert into employee values (6, 'Komal', 22, 'MP', 32000 );

数据的覆盖

Insert overwrite employee values (1, 'Ram', 26, 'Vishakhapatnam', 37000 );
执行覆盖之后,表中只剩下了这一条数据了

另外一种建表语句

create table customer as select * from employee;
3.2、 数据的查询
select * from employee;

select name,age from employee;
3.3、 删除表
DROP table  mydb1.employee;
3.4、 清空表数据
truncate  employee;
3.5、 查看视图数据
select * from employee_view;

4、 order by语句

基础语法

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]
Select * from employee ORDER BY id asc;

5、group by 语句

Select name, sum(salary) from employee Group BY name;

6、 having 语句

基础语法

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]

按年龄对表进行分组,并选择每个组的最大工资,并显示大于20000的工资

select max(salary) from employee group by age having max(salary) > 20000;

7、 limit语句

select * from employee order by id limit 4;

8、impala当中的数据表导入几种方式

第一种方式,通过load hdfs的数据到impala当中去

create table user(id int ,name string,age int ) row format delimited fields terminated by "\t";

准备数据user.txt并上传到hdfs的 /user/impala路径下去

1   hello   15
2   zhangsan    20
3   lisi    30
4   wangwu  50

加载数据

load data inpath '/user/impala/' into table user;

查询加载的数据

select  *  from  user;

如果查询不不到数据,那么需要刷新一遍数据表

refresh  user;

第二种方式:

create  table  user2   as   select * from  user;

第三种方式:

insert into 不推荐使用 因为会产生大量的小文件

千万不要把impala当做一个数据库来使用

第四种:

insert  into  select  用的比较多

9、impala的java开发

在实际工作当中,因为impala的查询比较快,所以可能有会使用到impala来做数据库查询的情况,我们可以通过java代码来进行操作impala的查询

第一步:导入jar包
  <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
        <repository>
            <id>central</id>
            <url>http://repo1.maven.org/maven2/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <dependencies>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.0-cdh5.14.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-common</artifactId>
            <version>1.1.0-cdh5.14.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-metastore</artifactId>
            <version>1.1.0-cdh5.14.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-service</artifactId>
            <version>1.1.0-cdh5.14.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>1.1.0-cdh5.14.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.1.0-cdh5.14.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.thrift/libfb303 -->
        <dependency>
            <groupId>org.apache.thrift</groupId>
            <artifactId>libfb303</artifactId>
            <version>0.9.0</version>
            <type>pom</type>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.thrift/libthrift -->
        <dependency>
            <groupId>org.apache.thrift</groupId>
            <artifactId>libthrift</artifactId>
            <version>0.9.0</version>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.2.5</version>
        </dependency>
    </dependencies>
第二步:impala的java代码查询开发
public class ImpalaJdbc {
     public static void main(String[] args) throws Exception {
     //定义连接驱动类,以及连接url和执行的sql**语句     
     String driver = "org.apache.hive.jdbc.HiveDriver";
     String driverUrl = "jdbc:hive2://192.168.52.120:21050/mydb1;auth=noSasl";
     String sql = "select * from student";

     //通过反射加载数据库连接驱动*    
     Class.forName(driver);
     Connection connection = DriverManager.getConnection(driverUrl);
     PreparedStatement preparedStatement = connection.prepareStatement(sql);
     ResultSet resultSet = preparedStatement.executeQuery();
     //通过查询,得到数据一共有多少列     
     int col = resultSet.getMetaData().getColumnCount();
     //遍历结果集     
     while (resultSet.next()){
         for(int i=1;i<=col;i++){
             System.out.print(resultSet.getString(i)+"\t");
         }
         System.out.print("\n");
     }
     preparedStatement.close();
     connection.close();
 }
 }

Views: 82

Flume 进阶

一、flume事务

file

put事务流程

1、doPut

将批量数据先写入临时缓冲区putList

2、doCommit

检查Channel内存队列是否足够,

(1)达到一定时间没有数据写入到putList

(2)达到了putListCapcity容量

3、doRollback

Channel内存队列空间不足,回滚数据到putList,会被channel打回来

take事务流程:

1、doTake

将数据取到临时缓冲区takeList,并将数据发送到HDFS

2、doCommit

如果数据全部发送成功,则清除临时缓冲区takeList

3、doRollback

数据发送过程中如果出现异常,rollback将临时缓冲区takeList中数据全部打回给Channel内存队列

二、Flume Agent内部原理

file

重要组件:
1)ChannelSelector
ChannelSelector的作用就是选出event将要被发往哪个Channel。

共有两种类型:Replicating(复制)和Multiplexing(多路复用)

ReplicatingSelector会将同一个event发往所有的Channel

MultiplexingSelector会根据相应的原则,将不同的event发往不同的Channel

2)SinkProcessor
sinkProcessor共有三种类型:DefaultSinkProcessor、LoadBalancingProcessor和FailoverSinkProcessor

DefaultSinkProcessor:对应的是单个sink

LoadBalancingProcessor:对应的是sink group,可以实现负载均衡

FailoverSinkProcessor:对应的是sink group,可以实现故障恢复

三、flume拓扑结构

1、简单串联

file

将多个flume顺序连接起来,从最初的Source开始到最终sink传送的目的存储系统。

此模式不建议桥接过多的flume数量,flume数据过多不仅会影响传输速率,而且一旦传输过程中某个节点flume宕机,会影响整个传输系统

2、复制和多路复用

file

flume支持将事件流向一个或者多个目的地。

这种模式可以将相同数据复制到多个Channel中,或者将不同数据分发到不同的Channel中,sink可以选择传送到不同的目的地

3、负载均衡和故障转移

file

flume支持使用将多个sink逻辑上分到一个sink组,sink组配合不同的sinkProcessor可以实现负载均衡和错误恢复的功能

4、聚合

file

这种模式是我们最常见的,也非常实用,日常web应用通常分布在上百个服务器,大者甚至上千个、上万个服务器。产生的日志,处理  起来也非常麻烦。

用flume的这种组合方式能很好的解决这一问题,每台服务器部署一个flume采集日志,传送到一个集中收集日志的flume,再由此flume  上传到hdfs、hive、hbase等,进行日志分析。

Views: 165

Presto分布式SQL查询引擎

一、课前准备

  1. jdk版本要求:Java 8 Update 151 or higher (8u151+), 64-bit
  2. 安装好hadoop集群
  3. 安装好hive

二、课堂主题

  1. 介绍presto
  2. presto架构
  3. prsto安装部署
  4. presto使用

三、课堂目标

  1. 理解presto
  2. 独立完成presto安装部署
  3. 使用presto

四、知识要点

1. Presto是什么?

  • Hadoop提供了大数据存储与计算的一整套解决方案;但是它采用的是MapReduce计算框架,只适合离线和批量计算,无法满足快速实时的Ad-Hoc查询计算的性能要求

  • Hive使用MapReduce作为底层计算框架,是专为批处理设计的。但随着数据越来越多,使用Hive进行一个简单的数据查询可能要花费几分到几小时,显然不能满足交互式查询的需求。

  • Facebook于2012年秋开始开发了Presto,每日查询数据量在1PB级别。Facebook称Presto的性能比Hive要快上10倍多。2013年Facebook正式宣布开源Presto。

  • Presto是apache下开源的==OLAP的分布式SQL查询引擎==,数据量支持从GB到PB级别的数据量的查询,并且查询时,能做到秒级查询。

  • 另外,Presto虽然可以解析SQL,但它并非是标准的数据库;不能替代如MySQL、PostgreSQL、Oracle关系型数据库,不是用于处理OLTP的

  • presto是利用分布式查询,高效的对海量数据进行查询;

  • presto可以用来查询hdfs上的海量数据;但是,presto不仅仅可以用来查询hdfs的数据,它还被设计成能够对很多其他的数据源的数据做查询;

  • 比如数据源有HDFS、Hive、Druid、Kafka、kudu、MySQL、Redis等;下图是Presto 0.237支持的数据源

    image-20200628160739942

2. Presto架构

  • Presto查询引擎是一个Master-Slave的架构,Coordinator是主,worker是从;
  • 一个presto集群,由一个Coordinator节点,一个Discovery Server节点(通常内嵌于Coordinator节点中),多个Worker节点组成
    • Coordinator负责接收查询请求、解析SQL语句、生成执行计划、任务调度给Worker节点执行、worker管理。
    • Worker节点是工作节点;负责实际执行查询任务Task;Worker节点启动后向Discovery Server服务注册;Coordinator从Discovery Server获得可以正常工作的Worker节点。
  • Presto CLI提交查询到Coordinator
  • catalog表示数据源;每个catalog包含Connector及Schema
    • 其中Connector是数据源的适配器;presto通过Connector与不同的数据源(如Redis、Hive、Kafka)连接;如果配置了Hive Connector,需要配置一个Hive MetaStore服务为Presto提供Hive元信息,Worker节点与HDFS交互读取数据。
    • Schema类似于MySQL中的数据库的概念;Schema中又包含Table,类似于MySQL中的表

3. Presto特点

1. 优点

  • 高性能:Presto基于内存计算,减少数据的落盘,计算更快;轻量快速,支持近乎实时的查询
  • 多数据源:通过配置不同的Connector,presto可以连接不同的数据源,所以可以将来自不同数据源的表进行连接查询
  • 支持SQL:完全支持ANSI SQL,并提供了sql shell命令行工具
  • 扩展性:可以根据实际的需要,开发特定的数据源的Connector,从而可以sql查询此数据元的数据

2. 缺点

  • 虽然Presto是基于内存做计算;但是数据量大时,数据并非全部存储在内存中;
    • 比如Presto可针对PB级别的数据做计算,但Presto并非将所有数据全部存储在内存中,不同场景有不同做法;
    • 比如count, avg等聚合运算,会读部分数据,计算,在清理内存;再读数据再计算、清理内存;所以占据内存并不是很高;
    • 但是如果做join操作,中间可能会产生大量的临时数据,造成执行速度变慢;join时,hive的数据反而更快些。所以如果join的话,建议在hive中,先进行join生成宽表,再使用presto查询此宽表数据

3. presto与impala对比

  • impala性能比presto稍好
  • 但是,impala只能对接hive;而presto能对接很多种类的数据源

4. 安装部署Presto

官网地址:https://prestodb.io/

github地址

presto集群规划

主机名 角色
node01 coordinator
node02 worker
node03 worker

1. 安装部署Presto Server

presto要求

image-20200629145103059

确认python版本是2.4+

python -V

image-20200629160952988

确认java版本是8u151+;若如下图,是151之前的版本,安装presto时,需要特殊处理

image-20200629161305214

1. 下载安装包

https://repo1.maven.org/maven2/com/facebook/presto/presto-server/0.237/presto-server-0.237.tar.gz

然后将tar.gz包上传到node01的/kkb/soft目录

2. 解压

cd /kkb/soft/
tar -xzvf presto-server-0.237.tar.gz -C /kkb/install/

3. 配置JAVA

若java版本低于8u151,那么需要上传8u151+的版本压缩包到/kkb/soft;若不低于,则跳过此步骤

解压

cd /kkb/soft/
tar -xzvf jdk-8u251-linux-x64.tar.gz -C /kkb/install/
cd /kkb/install/
scp -r jdk1.8.0_251/ node02:$PWD
scp -r jdk1.8.0_251/ node03:$PWD

presto-server目录创建软链接

ln -s presto-server-0.237/ presto

指定presto使用的java版本(3个节点都要修改)

vim /kkb/install/presto/bin/launcher

添加如下内容

PATH=/kkb/install/jdk1.8.0_251/bin:$PATH
java -version

注意:需要加在exec "$(dirname "$0")/launcher.py" "$@"之前

image-20200629174956052

3. 创建相关目录

创建存储数据文件夹;presto将存储log及其他数据到此目录

cd /kkb/install
cd presto
mkdir data

创建存储配置文件的文件夹

mkdir etc

4. 添加JVM配置文件

etc目录下添加jvm.config配置文件

cd /kkb/install/presto/etc
vim jvm.config

内容如下

-server
-Xmx16G
-XX:+UseG1GC
-XX:G1HeapRegionSize=32M
-XX:+UseGCOverheadLimit
-XX:+ExplicitGCInvokesConcurrent
-XX:+HeapDumpOnOutOfMemoryError
-XX:+ExitOnOutOfMemoryError

5. 配置数据源

  • presto支持不同的数据源,通过catalog进行配置;不同的数据源,有不同的catalog
  • 现以hive数据源为例,创建个hive的catalog
  • etc中创建目录catalog
cd /kkb/install/presto-server-0.237/etc
mkdir catalog
cd catalog
vim hive.properties
  • 添加如下内容
connector.name=hive-hadoop2
hive.metastore.uri=thrift://node03:9083

6. 分发presto

cd /kkb/install/
scp -r presto node02:/kkb/install/
scp -r presto node03:/kkb/install/

7. 配置node.properties

  • 进入三台节点的/kkb/install/presto/etc目录,修改node.properties文件
cd /kkb/install/presto/etc
vim node.properties
  • 三台节点的内容分别如下
# node01如下内容
node.environment=production
node.id=ffffffff-ffff-ffff-ffff-fffffffffff1
node.data-dir=/kkb/install/presto/data

# node2如下内容
node.environment=production
node.id=ffffffff-ffff-ffff-ffff-fffffffffff2
node.data-dir=/kkb/install/presto/data

# node03如下内容
node.environment=production
node.id=ffffffff-ffff-ffff-ffff-fffffffffff3
node.data-dir=/kkb/install/presto/data

说明:

node.environment 环境的名称;presto集群各节点的此名称必须保持一致

node.id presto每个节点的id,必须唯一

node.data-dir 存储log及其他数据的目录

8. 配置config.properties

  • 通过配置config.properties文件,指明server是coordinator还是worker

  • 虽然presto server可以同时作为coordinator和worker;但是为了更好的性能,一般让server要么作为coordinator,要么作为worker

  • presto是主从架构;主是coordinator,从是worker

  • 现设置node01作为coordinator节点;node02、node03节点作为worker节点

  • node01上配置coordinator

cd /kkb/install/presto/etc
vim config.properties
  • 添加如下内容
coordinator=true
node-scheduler.include-coordinator=false
http-server.http.port=8880
query.max-memory=50GB
query.max-memory-per-node=1GB
discovery-server.enabled=true
discovery.uri=http://node01:8880

说明:

coordinator=true 允许此presto实例作为coordinator

node-scheduler.include-coordinator 是否允许在coordinator上运行work

http-server.http.port presto使用http服务进行内部、外部的通信;指定http server的端口

query.max-memory 一个查询运行时,使用的所有的分布式内存的总量的上限

query.max-memory-per-node query在执行时,使用的任何一个presto服务器上使用的内存上限

discovery-server.enabled presto使用discovery服务,用来发现所有的presto节点

discovery.uri discovery服务的uri

  • node02、node03上配置worker
cd /kkb/install/presto/etc
vim config.properties
  • 添加如下内容
coordinator=false
http-server.http.port=8880
query.max-memory=50GB
discovery.uri=http://node01:8880

9. 启动presto server

  • 若要用presto对接hive数据,需要启动hive metastore服务
  • 上课环境:hive安装在node03上,所以在node03启动metastore服务
nohup hive --service metastore > /dev/null 2>&1 &
  • 在node01、node02、node03上分别启动presto server,执行以下命令
cd /kkb/install/presto
# 前台启动,控制台打印日志
bin/launcher run
# 或使用后台启动presto
bin/launcher start
  • jps查看,各节点出现名为PrestoServer的进程
  • 日志所在目录
/kkb/install/presto/data/var/log

2. 安装部署Presto命令行接口

1. 下载安装包

2. 重命名文件

cd /kkb/soft
mv presto-cli-0.237-executable.jar prestocli

3. 增加可执行权限

chmod u+x prestocli

4. 启动presto cli

  • 注意:先启动HDFS

  • 查看presto客户端jar包的使用方式

./prestocli --help
  • 两种方式;方式一
./prestocli --server node01:8880 --catalog hive --schema default

说明:

--catalog hive 中的hive指的是presto/etc/catalog中的hive.properties的文件名

  • 方式二
java -jar presto-cli-0.237-executable.jar --server node01:8880 --catalog hive --schema default
  • 退出presto cli
quit

5. 体验命令操作

Presto的命令行操作,相当于Hive命令行操作。每个表必须要加上schema前缀;例如

select * from schema.<tablename> limit 5;

或者切换到指定的schema,再查询表数据

use myhive;
select * from score limit 3;

异常处理:在node01进行presto查询时没有响应

presto:default> show tables;

Query 20191008_100336_00007_kdyy2, WAITING_FOR_RESOURCES, 0 nodes, 0 splits

解决办法:这是因为在前面的配置中node01只配置了coordinator,不允许worker同时运行,如果想要node01既运行coordinator又同时运行worker,需要修改配置文件:

vim ./etc/config.properties

...
node-scheduler.include-coordinator=true
...

3. 安装部署Presto 可视化客户端

1. 下载安装包

  • presto有个开源的带可视化界面的客户端yanagishima
  • 源码下载地址:yanagishima
  • 官网地址
  • 将下载的包yanagishima-18.0.zip上传到node01点/kkb/soft目录

2. 解压缩

cd /kkb/soft
unzip -d /kkb/install yanagishima-18.0.zip

# 若出现-bash: unzip: command not found,表示没有安装unzip;需要安装;然后再解压缩
sudo yum -y install unzip zip

cd /kkb/install/yanagishima-18.0

3. 修改配置文件

  • 修改yanagishima.properties文件
cd /kkb/install/yanagishima-18.0/conf
vim yanagishima.properties
  • 添加如下内容
jetty.port=7080
presto.datasources=kkb-presto
presto.coordinator.server.kkb-presto=http://node01:8880
catalog.kkb-presto=hive
schema.kkb-presto=default
sql.query.engines=presto

注意这里kkb-presto是数据源的名称,可以自定义

4. 启动yanagishima

nohup bin/yanagishima-start.sh >yanagishima.log 2>&1 &
  • 注意一定要进入yanagishima的安装目录下以相对路径方式执行以上命令启动

  • node01上多出名为YanagishimaServer的进程

  • 启动web界面

    http://node01:7080

    在界面中进行查询了

    若ui界面显示很慢,或者不显示,可以尝试将node01替换成相应的ip地址

  • 查看表结构;

  • 每个表后面都有个复制键,点一下会复制完整的表名,然后再上面框里面输入sql语句,ctrl+enter组合键或Run按钮执行显示结果

image-20200630111827193

  • 这里有个Tree View,可以查看所有表的结构,包括Schema、表、字段等。

  • 比如执行select * from hive.myhive.score,这个句子里Hive这个词可以删掉,即变成select * from myhive.score;hive是上面配置的Catalog名称

  • 特别注意:sql语句末尾千万不要加分号;否则报错

image-20200630112056143

5. Presto查询及优化

1. Presto sql语法

以下用presto的客户端连接hive connector来进行演示

如果使用UI界面演示去掉SQL语句最后面的分号即可

查看schema有哪些(对应hive中的database)

SHOW SCHEMAS;

进入schema

use myhive;

查看有哪些表

SHOW TABLES;

创建schema

语法:CREATE SCHEMA [ IF NOT EXISTS ] schema_name

CREATE SCHEMA testschema;

删除schema

语法:DROP SCHEMA [ IF EXISTS ] schema_name
drop schema testschema;

创建表

语法:CREATE TABLE [ IF NOT EXISTS ]
table_name (column_name data_type [ COMMENT comment],... ]

create table stu4(id int, name varchar(20));

创建表CTAS

语法:
CREATE TABLE [ IF NOT EXISTS ] table_name [ ( column_alias, ... ) ]
[ COMMENT table_comment ]
[ WITH ( property_name = expression [, ...] ) ]
AS query
[ WITH [ NO ] DATA ]

create table if not exists myhive.stu5 as select id, name from stu1;

删除表中符合条件的行

语法:DELETE FROM table_name [ WHERE condition ]
说明:hive connector只支持一次性的删除一个完整的分区;不支持删除一行数据

DELETE FROM order_partition where month='2019-03';

查看表的描述信息

DESCRIBE hive.myhive.stu1;

ANALYZE获得表及列的统计信息

语法:ANALYZE table_name

ANALYZE hive.myhive.stu1;

prepare 给statement起一个名称,等待将来的执行

execute执行一个准备好的statement

语法:PREPARE statement_name FROM statement

prepare my_select1 from select * from score;
execute my_select1;

prepare my_select2 from select * from score where s_score < 90 and s_score > 70;
execute my_select2;

prepare my_select3 from select * from score where s_score < ? and s_score > ?;
execute my_select3 using 90, 70;

EXPLAIN:查询一个statement的逻辑计划或分布式执行计划,或校验statement

语法:
EXPLAIN [ ( option [, ...] ) ] statement

where option can be one of:

    FORMAT { TEXT | GRAPHVIZ | JSON }
    TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO }

查询逻辑计划语句:
explain select s_id, avg(s_score) from score group by s_id;
等价于
explain (type logical)select s_id, avg(s_score) from score group by s_id;

查询分布式执行计划distributed execution plan
explain (type distributed)select s_id, avg(s_score) from score group by s_id;

校验语句的正确性
explain (type validate)select s_id, avg(s_score) from score group by s_id;

explain (type io, format json)select s_id, avg(s_score) from score group by s_id;

SELECT查询

语法:
[ WITH with_query [, ...] ]
SELECT [ ALL | DISTINCT ] select_expr [, ...]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
[ HAVING condition]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
[ ORDER BY expression [ ASC | DESC ] [, ...] ]
[ LIMIT [ count | ALL ] ]

from_item:
table_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
from_item join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]

join_type:
[ INNER ] JOIN
LEFT [ OUTER ] JOIN
RIGHT [ OUTER ] JOIN
FULL [ OUTER ] JOIN
CROSS JOIN

grouping_element:
()
expression
GROUPING SETS ( ( column [, ...] ) [, ...] )
CUBE ( column [, ...] )
ROLLUP ( column [, ...] )

语句:
with语句:用于简化内嵌的子查询
select a, b
from (
select s_id as a, avg(s_score) as b from score group by s_id
) as tbl1;

等价于:
with tbl1 as (select s_id as a, avg(s_score) as b from score group by s_id)
select a, b from tbl1;

多个子查询也可以用with
WITH
  t1 AS (SELECT a, MAX(b) AS b FROM x GROUP BY a),
  t2 AS (SELECT a, AVG(d) AS d FROM y GROUP BY a)
SELECT t1.*, t2.*
FROM t1
JOIN t2 ON t1.a = t2.a;

with语句中的关系可以串起来(chain)
WITH
  x AS (SELECT a FROM t),
  y AS (SELECT a AS b FROM x),
  z AS (SELECT b AS c FROM y)
SELECT c FROM z;

group by:
select s_id as a, avg(s_score) as b from score group by s_id;
等价于:
select s_id as a, avg(s_score) as b from score group by 1;
1代表查询输出中的第一列s_id

select count(*) as b from score group by s_id;

2. 存储优化

  • 合理设置分区

    与Hive类似,Presto会根据元信息读取分区数据,合理的分区能减少Presto数据读取量,提升查询性能。

  • 使用列式存储

    Presto对ORC文件读取做了特定优化,因此在Hive中创建Presto使用的表时,建议采用ORC格式存储。相对于Parquet,Presto对ORC支持更好。

  • 使用压缩

    数据压缩可以减少节点间数据传输对IO带宽压力,对于即席查询需要快速解压,建议采用snappy压缩

  • 预先排序

    对于已经排序的数据,在查询的数据过滤阶段,ORC格式支持跳过读取不必要的数据。比如对于经常需要过滤的字段可以预先排序。

3. SQL优化

  • 列剪裁

    只选择使用必要的字段: 由于采用列式存储,选择需要的字段可加快字段的读取、减少数据量。避免采用*读取所有字段

[GOOD]: SELECT s_id, c_id FROM score

[BAD]:  SELECT * FROM score
  • 过滤条件必须加上分区字段

    对于分区表,where语句中优先使用分区字段进行过滤。day是分区字段,vtime是具体访问时间

[GOOD]: SELECT vtime, stu, address FROM tbl where day=20200501

[BAD]:  SELECT * FROM tbl where vtime=20200501
  • Group By语句优化:

    合理安排Group by语句中字段顺序对性能有一定提升。将Group By语句中字段按照每个字段distinct数据多少进行降序排列, 减少GROUP BY语句后面的排序一句字段的数量能减少内存的使用.

uid个数多;gender少
[GOOD]: SELECT GROUP BY uid, gender

[BAD]:  SELECT GROUP BY gender, uid
  • Order by时使用Limit, 尽量避免ORDER BY: Order by需要扫描数据到单个worker节点进行排序,导致单个worker需要大量内存
[GOOD]: SELECT * FROM tbl ORDER BY time LIMIT 100

[BAD]:  SELECT * FROM tbl ORDER BY time
  • 使用近似聚合函数: 对于允许有少量误差的查询场景,使用这些函数对查询性能有大幅提升。比如使用approx_distinct() 函数比Count(distinct x)有大概2.3%的误差
select approx_distinct(s_id) from score;
  • 用regexp_like代替多个like语句: Presto查询优化器没有对多个like语句进行优化,使用regexp_like对性能有较大提升
SELECT
...
FROM
access
WHERE
method LIKE '%GET%' OR
method LIKE '%POST%' OR
method LIKE '%PUT%' OR
method LIKE '%DELETE%'

优化:
SELECT
...
FROM
access
WHERE
regexp_like(method, 'GET|POST|PUT|DELETE')
  • 使用Join语句时将大表放在左边: Presto中join的默认算法是broadcast join,即将join左边的表分割到多个worker,然后将join右边的表数据整个复制一份发送到每个worker进行计算。如果右边的表数据量太大,则可能会报内存溢出错误。
[GOOD] SELECT ... FROM large_table l join small_table s on l.id = s.id
[BAD] SELECT ... FROM small_table s join large_table l on l.id = s.id
  • 使用Rank函数代替row_number函数来获取Top N

  • UNION ALL 代替 UNION :不用去重

  • 使用WITH语句: 查询语句非常复杂或者有多层嵌套的子查询,请试着用WITH语句将子查询分离出来

6. 其他注意事项

1. 字段名引用

  • 避免和关键字冲突:MySQL对字段加反引号`;Presto对字段加双引号分割

    当然,如果字段名称不是关键字,可以不加这个双引号。

2. 函数

  • 对于Timestamp,需要进行比较的时候,需要添加Timestamp关键字,而MySQL中对Timestamp可以直接进行比较。
/*MySQL的写法*/
SELECT t FROM a WHERE t > '2020-05-01 00:00:00'; 

/*Presto的写法*/
SELECT t FROM a WHERE t > timestamp '2020-05-01 00:00:00';

3. 不支持INSERT OVERWRITE语法

  • Presto中不支持insert overwrite语法,只能先delete,然后insert into。

4. QUET格式

  • Presto目前支持Parquet格式,支持查询,但不支持insert

五、拓展

Views: 28

Maxwell 数据库数据实时采集

1、Maxwell 简介

Maxwell 是一个能实时读取 MySQL 二进制日志文件binlog,并生成 Json格式的消息,作为生产者发送给 Kafka,Kinesis、RabbitMQ、Redis、Google Cloud Pub/Sub、文件或其它平台的应用程序。它的常见应用场景有ETL、维护缓存、收集表级别的dml指标、增量到搜索引擎、数据分区迁移、切库binlog回滚方案等。

Maxwell主要提供了下列功能

    1. 支持SELECT * FROM table的方式进行全量数据初始化。
    1. 支持在主库发生failover后,自动恢复binlog位置,实现断点续传。
    1. 可以对数据进行分区,解决数据倾斜问题,发送到Kafka的数据支持库、表、列等级别的数据分区。
    1. 工作方式是伪装为slave接收binlog events,然后根据schema信息拼装,可以接受ddl、xid、row等event。

2、Mysql Binlog介绍

2.1 Binlog 简介

MySQL中一般有以下几种日志

日志类型 写入日志的信息
错误日志 记录在启动,运行或停止mysqld时遇到的问题
通用查询日志 记录建立的客户端连接和执行的语句
二进制日志 binlog 记录更改数据的语句
中继日志 从服务器 复制 主服务器接收的数据更改
慢查询日志 记录所有执行时间超过 long_query_time 秒的所有查询或不使用索引的查询
DDL日志(元数据日志) 元数据操作由DDL语句执行

在默认情况下,系统仅仅打开错误日志,关闭了其他所有日志,以达到尽可能减少IO损耗提高系统性能的目的,但是在一般稍微重要一点的实际应用场景中,都至少需要打开二进制日志,因为这是MySQL很多存储引擎进行增量备份的基础,也是MySQL实现复制的基本条件

接下来主要介绍二进制日志 binlog。

MySQL 的二进制日志 binlog 可以说是 MySQL 最重要的日志,它记录了所有的 DDLDML 语句(除了数据查询语句select、show等),以事件形式记录,还包含语句所执行的消耗的时间,MySQL的二进制日志是事务安全型的。binlog 的主要目的是复制和恢复

Binlog日志的两个最重要的使用场景

  • MySQL主从复制
    • MySQL Replication在Master端开启binlog,Master把它的二进制日志传递给slaves来达到master-slave数据一致的目的。
  • 数据恢复
    • 通过使用 mysqlbinlog工具来使恢复数据。

2.2 Binlog 的日志格式

记录在二进制日志中的事件的格式取决于二进制记录格式。支持三种格式类型:

  • Statement:基于SQL语句的复制(statement-based replication, SBR)
  • Row:基于行的复制(row-based replication, RBR)
  • Mixed:混合模式复制(mixed-based replication, MBR)

Statement

  • 每一条会修改数据的sql都会记录在binlog中。
  • 优点
    • 不需要记录每一行的变化,减少了binlog日志量,节约了IO, 提高了性能。
  • 缺点
    • 在进行数据同步的过程中有可能出现数据不一致。
    • 比如 update tt set create_date=now(),如果用binlog日志进行恢复,由于执行时间不同可能产生的数据就不同。

Row

  • 它不记录sql语句上下文相关信息,仅保存哪条记录被修改。
  • 优点
    • 保持数据的绝对一致性。因为不管sql是什么,引用了什么函数,它只记录执行后的效果。
  • 缺点
    • 每行数据的修改都会记录,最明显的就是update语句,导致更新多少条数据就会产生多少事件,占用较大空间。

Mixed

  • 从5.1.8版本开始,MySQL提供了Mixed格式,实际上就是Statement与Row的结合。
  • 在Mixed模式下,一般的复制使用Statement模式保存binlog,对于Statement模式无法复制的操作使用Row模式保存binlog, MySQL会根据执行的SQL语句选择日志保存方式(因为statement只有sql,没有数据,无法获取原始的变更日志,所以一般建议为Row模式)。
  • 优点
    • 节省空间,同时兼顾了一定的一致性。
  • 缺点
    • 还有些极个别情况依旧会造成不一致,另外statement和mixed对于需要对binlog的监控的情况都不方便。

3、Mysql 实时数据同步方案对比

  • mysql 数据实时同步可以通过解析mysql的 binlog 的方式来实现,解析binlog可以有多种方式,可以通过canal,或者maxwell等各种方式实现。以下是各种抽取方式的对比介绍。

    mysql实时同步方案对比

  • 其中canal 由 Java开发,分为服务端和客户端,拥有众多的衍生应用,性能稳定,功能强大;canal 需要自己编写客户端来消费canal解析到的数据。

  • Maxwell相对于canal的优势是使用简单,Maxwell比Canal更加轻量级,它直接将数据变更输出为json字符串,不需要再编写客户端。对于缺乏基础建设,短时间内需要快速迭代的项目和公司比较合适。

  • 另外Maxwell 有一个亮点功能,就是Canal只能抓取最新数据,对已存在的历史数据没有办法处理。而Maxwell有一个bootstrap功能,可以直接引导出完整的历史数据用于初始化,非常好用。

4、开启Mysql的Binlog

  • 1、服务器当中安装mysql(省略)

    • 注意:mysql的版本尽量不要太低,也不要太高,最好使用5.6及以上版本。
  • 2、添加mysql普通用户maxwell

    • 为mysql添加一个普通用户maxwell,因为maxwell这个软件默认用户使用的是maxwell这个用户。

    • 进入mysql客户端,然后执行以下命令,进行授权

    mysql -uroot -p123456
    • 执行sql语句
    --校验级别最低,只校验密码长度
    mysql> set global validate_password_policy=LOW;
    mysql> set global validate_password_length=6;
    
    --创建maxwell库(启动时候会自动创建,不需手动创建)和用户
    mysql> CREATE USER 'maxwell'@'%' IDENTIFIED BY '123456';
    mysql> GRANT ALL ON maxwell.* TO 'maxwell'@'%';
    mysql> GRANT SELECT, REPLICATION CLIENT, REPLICATION SLAVE on *.* to 'maxwell'@'%'; 
    --刷新权限
    mysql> flush privileges;

    maxwell会自动在MySQL中创建名为maxwell的数据库作为元数据保存使用。

  • 3、修改配置文件 /etc/my.cnf

    • 执行命令 sudo vim /etc/my.cnf, 添加或修改以下三行配置
    #binlog日志名称前缀
    log-bin= /var/lib/mysql/mysql-bin
    
    #binlog日志格式
    binlog-format=ROW
    
    #唯一标识,这个值的区间是:1到(2^32)-1
    server_id=1
  • 4、重启mysql服务

    • 执行如下命令
    sudo service mysqld restart
  • 5、验证binlog是否配置成功

    • 进入mysql客户端,并执行以下命令进行验证
    mysql -uroot -p123456
    mysql> show variables like '%log_bin%';

    image-20210517161330004

  • 6、查看binlog日志文件生成

    • 进入 /var/lib/mysql 目录,查看binlog日志文件.

    image-20210517162315281

5、Maxwell安装部署

  • 1、下载对应版本的安装包

  • 2、上传服务器

  • 3、解压安装包到指定目录

    tar -zxvf maxwell-1.21.1.tar.gz -C /kkb/install/
  • 4、修改maxwell配置文件

    • 进入到安装目录 /kkb/install/maxwell-1.21.1 进行如下操作
    cd /kkb/install/maxwell-1.21.1 
    cp config.properties.example config.properties
    vim config.properties
    • 配置文件config.properties 内容如下:
    # choose where to produce data to
    producer=kafka
    # list of kafka brokers
    kafka.bootstrap.servers=node01:9092,node02:9092,node03:9092
    # mysql login info
    host=node03
    port=3306
    user=maxwell
    password=123456
    # kafka topic to write to
    kafka_topic=maxwell
    • 注意:一定要保证使用maxwell 用户和 123456 密码能够连接上mysql数据库。

6、kafka介绍和使用

6.1 Kafka简介

​ Kafka是最初由Linkedin公司开发,它是一个分布式、可分区、多副本,基于zookeeper协调的分布式日志系统;常见可以用于web/nginx日志、访问日志,消息服务等等。Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。主要应用场景是:日志收集系统和消息系统

​ Kafka是一个分布式消息队列。具有高性能、持久化、多副本备份、横向扩展能力。生产者往队列里写消息,消费者从队列里取消息进行业务逻辑。Kafka就是一种发布-订阅模式。将消息保存在磁盘中,以顺序读写方式访问磁盘,避免随机读写导致性能瓶颈。

  • 消息(Message)
    • 是指在应用之间传送的数据,消息可以非常简单,比如只包含文本字符串,也可以更复杂,可能包含嵌入对象。
  • 消息队列(Message Queue)
    • 一种应用间的通信方式,消息发送后可以立即返回,通过消息系统来确保信息的可靠传递,消息发布者只管把消息发布到MQ中而不管谁来取,消息使用者只管从MQ中取消息而不管谁发布的,这样发布者和使用者都不用知道对方的存在。

6.2 Kafka特性

  • 高吞吐、低延迟

    kafka 最大的特点就是收发消息非常快,kafka 每秒可以处理几十万条消息,它的最低延迟只有几毫秒。
  • 高伸缩性

    每个主题(topic) 包含多个分区(partition),主题中的分区可以分布在不同的主机(broker)中。
  • 持久性、可靠性

    Kafka 能够允许数据的持久化存储,消息被持久化到磁盘,并支持数据备份防止数据丢失。
  • 容错性

    允许集群中的节点失败,某个节点宕机,Kafka 集群能够正常工作。
  • 高并发

    支持数千个客户端同时读写。

6.3 Kafka集群架构

kafka集群架构

  • producer

    消息生产者,发布消息到Kafka集群的终端或服务。
  • broker

    Kafka集群中包含的服务器,一个borker就表示kafka集群中的一个节点。
  • topic

    每条发布到Kafka集群的消息属于的类别,即Kafka是面向 topic 的。
    更通俗的说Topic就像一个消息队列,生产者可以向其写入消息,消费者可以从中读取消息,一个Topic支持多个生产者或消费者同时订阅它,所以其扩展性很好。
  • partition

    每个 topic 包含一个或多个partition。Kafka分配的单位是partition。
  • replica

    partition的副本,保障 partition 的高可用。
  • consumer

    从Kafka集群中消费消息的终端或服务。
  • consumer group

    每个 consumer 都属于一个 consumer group,每条消息只能被 consumer group 中的一个 Consumer 消费,但可以被多个 consumer group 消费。
  • leader

    每个partition有多个副本,其中有且仅有一个作为Leader,Leader是当前负责数据的读写的partition。 producer 和 consumer 只跟 leader 交互。
  • follower

    Follower跟随Leader,所有写请求都通过Leader路由,数据变更会广播给所有Follower,Follower与Leader保持数据同步。如果Leader失效,则从Follower中选举出一个新的Leader。
  • controller

    知道大家有没有思考过一个问题,就是Kafka集群中某个broker宕机之后,是谁负责感知到他的宕机,以及负责进行Leader Partition的选举?如果你在Kafka集群里新加入了一些机器,此时谁来负责把集群里的数据进行负载均衡的迁移?包括你的Kafka集群的各种元数据,比如说每台机器上有哪些partition,谁是leader,谁是follower,是谁来管理的?如果你要删除一个topic,那么背后的各种partition如何删除,是谁来控制?还有就是比如Kafka集群扩容加入一个新的broker,是谁负责监听这个broker的加入?如果某个broker崩溃了,是谁负责监听这个broker崩溃?这里就需要一个Kafka集群的总控组件,Controller。他负责管理整个Kafka集群范围内的各种东西。
    
  • zookeeper

    (1)   Kafka 通过 zookeeper 来存储集群的meta元数据信息。
    (2)一旦controller所在broker宕机了,此时临时节点消失,集群里其他broker会一直监听这个临时节点,发现临时节点消失了,就争抢再次创建临时节点,保证有一台新的broker会成为controller角色。
  • offset

    • 偏移量
    消费者在对应分区上已经消费的消息数(位置),offset保存的地方跟kafka版本有一定的关系。
    kafka0.8 版本之前offset保存在zookeeper上。
    kafka0.8 版本之后offset保存在kafka集群上。
    它是把消费者消费topic的位置通过kafka集群内部有一个默认的topic,
    名称叫 __consumer_offsets,它默认有50个分区。

6.4 Kafka集群安装部署

  • 1、下载安装包(http://kafka.apache.org

    kafka_2.11-1.1.0.tgz
  • 2、规划安装目录

    /kkb/install
  • 3、上传安装包到服务器中

    通过FTP工具上传安装包到node01服务器上
  • 4、解压安装包到指定规划目录

    tar -zxvf kafka_2.11-1.1.0.tgz -C /kkb/install
  • 5、重命名解压目录

    mv kafka_2.11-1.1.0 kafka
  • 6、修改配置文件

    • 在node01上修改

    • 进入到kafka安装目录下有一个config目录

      • vi server.properties
      #指定kafka对应的broker id ,唯一
      broker.id=0
      #指定数据存放的目录
      log.dirs=/kkb/install/kafka/kafka-logs
      #指定zk地址
      zookeeper.connect=node01:2181,node02:2181,node03:2181
      #指定是否可以删除topic ,默认是false 表示不可以删除
      delete.topic.enable=true
      #指定broker主机名
      host.name=node01
    • 配置kafka环境变量

      • sudo vi /etc/profile
      export KAFKA_HOME=/kkb/install/kafka
      export PATH=$PATH:$KAFKA_HOME/bin
  • 6、分发kafka安装目录到其他节点

    scp -r kafka node02:/kkb/install
    scp -r kafka node03:/kkb/install
    scp /etc/profile node02:/etc
    scp /etc/profile node03:/etc
  • 7、修改node02和node03上的配置

    • node02

    • vi server.properties

      #指定kafka对应的broker id ,唯一
      broker.id=1
      #指定数据存放的目录
      log.dirs=/kkb/install/kafka/kafka-logs
      #指定zk地址
      zookeeper.connect=node01:2181,node02:2181,node03:2181
      #指定是否可以删除topic ,默认是false 表示不可以删除
      delete.topic.enable=true
      #指定broker主机名
      host.name=node02
    • node03

    • vi server.properties

      #指定kafka对应的broker id ,唯一
      broker.id=2
      #指定数据存放的目录
      log.dirs=/kkb/install/kafka/kafka-logs
      #指定zk地址
      zookeeper.connect=node01:2181,node02:2181,node03:2181
      #指定是否可以删除topic ,默认是false 表示不可以删除
      delete.topic.enable=true
      #指定broker主机名
      host.name=node03
  • 8、让每台节点的kafka环境变量生效

    • 在每台服务器执行命令
    source /etc/profile

6.5 kafka集群启动和停止

  • 1、启动kafka集群

    • 先启动zookeeper集群,然后在所有节点如下执行脚本
    nohup kafka-server-start.sh /kkb/install/kafka/config/server.properties >/dev/null 2>&1 &
  • 2、停止kafka集群

    • 所有节点执行关闭kafka脚本
    kafka-server-stop.sh

6.6 kafka命令行的管理使用

  • 1、创建topic

    • 使用 kafka-topics.sh脚本
    kafka-topics.sh --create --partitions 3 --replication-factor 2 --topic test --zookeeper node01:2181,node02:2181,node03:2181
  • 2、查询所有的topic

    • 使用 kafka-topics.sh脚本
    kafka-topics.sh --list --zookeeper node01:2181,node02:2181,node03:2181 
  • 3、查看topic的描述信息

    • 使用 kafka-topics.sh脚本
    kafka-topics.sh --describe --topic test --zookeeper node01:2181,node02:2181,node03:2181  
  • 4、删除topic

    • 使用 kafka-topics.sh脚本
    kafka-topics.sh --delete --topic test --zookeeper node01:2181,node02:2181,node03:2181 
  • 5、模拟生产者写入数据到topic中

    • 使用 kafka-console-producer.sh 脚本
    kafka-console-producer.sh --broker-list node01:9092,node02:9092,node03:9092 --topic test 
  • 6、模拟消费者拉取topic中的数据

    • 使用 kafka-console-consumer.sh 脚本
    kafka-console-consumer.sh --zookeeper node01:2181,node02:2181,node03:2181 --topic test --from-beginning

    或者(推荐)

    kafka-console-consumer.sh --bootstrap-server node01:9092,node02:9092,node03:9092 --topic test --from-beginning

7、Maxwell实时采集mysql表数据到kafka

  • 1、启动kafka集群和zookeeper集群

    • 启动zookeeper集群
    #每台节点执行脚本
    nohup zkServer.sh start >/dev/null  2>&1 &
    • 启动kafka集群
    nohup /kkb/install/kafka/bin/kafka-server-start.sh /kkb/install/kafka/co
    nfig/server.properties > /dev/null 2>&1 &
  • 2、创建topic

    kafka-topics.sh --create --topic maxwell --partitions 3 --replication-factor 2 --zookeeper node01:2181,node02:2181,node03:2181

    (如果虚拟机磁盘容量有效,可以将分区数和复制因子都设置为1.)

  • 3、启动maxwell服务

    /kkb/install/maxwell-1.21.1/bin/maxwell
  • 4、插入数据并进行测试

    • 向mysql表中插入一条数据,并开启kafka的消费者,查看kafka是否能够接收到数据。

    • 向mysql当中创建数据库和数据库表并插入数据

      CREATE DATABASE /*!32312 IF NOT EXISTS*/<code>test_db /*!40100 DEFAULT CHARACTER SET utf8 */;
      
      USE test_db;
      
      /*Table structure for table user */
      
      DROP TABLE IF EXISTS user;
      
      CREATE TABLE user (
      id varchar(10) NOT NULL,
      name varchar(10) DEFAULT NULL,
      age int(11) DEFAULT NULL,
      PRIMARY KEY (id)
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
      
      /*Data for the table user */
      #插入数据
      insert  into user(id,name,age) values  ('1','xiaokai',20);
      #修改数据
      update user set age= 30 where id='1';
      #删除数据
      delete from user where id='1';
  • 5、启动kafka的自带控制台消费者

    • 启动Kafka消费者监听maxwell主题
    kafka-console-consumer.sh --topic maxwell --bootstrap-server node01:9092,node02:9092,node03:9092 --from-beginning 
    • 等待一段事件,观察maxwell主题是否有消息发送过来
    {"database":"test_db","table":"user","type":"insert","ts":1621244407,"xid":985,"commit":true,"data":{"id":"1","name":"xiaokai","age":20}}
    
    {"database":"test_db","table":"user","type":"update","ts":1621244413,"xid":999,"commit":true,"data":{"id":"1","name":"xiaokai","age":30},"old":{"age":20}}
    
    {"database":"test_db","table":"user","type":"delete","ts":1621244419,"xid":1013,"commit":true,"data":{"id":"1","name":"xiaokai","age":30}}
    • json数据字段说明

    • database

      • 数据库名称
    • table

      • 表名称
    • type

      • 操作类型
      • 包括 insert/update/delete 等
    • ts

      • 操作时间戳
    • xid

      • 事务id
    • commit

      • 同一个xid代表同一个事务,事务的最后一条语句会有commit
    • data

      • 最新的数据,修改后的数据
    • old

      • 旧数据,修改前的数据

Views: 30

Flume综合案例之拦截器

Flume综合案例之静态拦截器使用

1. 案例场景

  • A、B两台日志服务机器实时生产日志主要类型为access.log、nginx.log、web.log

  • 现在需要把A、B 机器中的access.log、nginx.log、web.log 采集汇总到C机器上然后统一收集到hdfs中。

  • 但是在hdfs中要求的目录为:

/source/logs/access/20200210/**
/source/logs/nginx/20200210/**
/source/logs/web/20200210/**

2. 场景分析

image-20200522145357477

3. 数据流程处理分析

image-20200522145429320

4. 实现

  • 服务器A对应的IP为 192.168.52.100

  • 服务器B对应的IP为 192.168.52.110

  • 服务器C对应的IP为 192.168.52.120

采集端配置文件开发
  • node01与node02服务器开发flume的配置文件
cd /kkb/install/apache-flume-1.9.0-bin/conf/
vim exec_source_avro_sink.conf
  • 内容如下
# Name the components on this agent
a1.sources = r1 r2 r3
a1.sinks = k1
a1.channels = c1

# set source
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F /kkb/install/taillogs/access.log
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = static
##  static拦截器的功能就是往采集到的数据的header中插入自定义的key-value对;与node03上的agent的sink中的type相呼应
a1.sources.r1.interceptors.i1.key = type
a1.sources.r1.interceptors.i1.value = access

a1.sources.r2.type = exec
a1.sources.r2.command = tail -F /kkb/install/taillogs/nginx.log
a1.sources.r2.interceptors = i2
a1.sources.r2.interceptors.i2.type = static
a1.sources.r2.interceptors.i2.key = type
a1.sources.r2.interceptors.i2.value = nginx

a1.sources.r3.type = exec
a1.sources.r3.command = tail -F /kkb/install/taillogs/web.log
a1.sources.r3.interceptors = i3
a1.sources.r3.interceptors.i3.type = static
a1.sources.r3.interceptors.i3.key = type
a1.sources.r3.interceptors.i3.value = web

# set sink
a1.sinks.k1.type = avro
a1.sinks.k1.hostname = node03
a1.sinks.k1.port = 41415

# set channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 20000
a1.channels.c1.transactionCapacity = 10000

# Bind the source and sink to the channel
a1.sources.r1.channels = c1
a1.sources.r2.channels = c1
a1.sources.r3.channels = c1
a1.sinks.k1.channel = c1

static interceptor 静态拦截器

服务端配置文件开发
  • 在node03上面开发flume配置文件
cd /kkb/install/apache-flume-1.9.0-bin/conf/
vim avro_source_hdfs_sink.conf
  • 内容如下
# Name the components on this agent
a1.sources = r1
a1.sinks = k1
a1.channels = c1

#定义source
a1.sources.r1.type = avro
a1.sources.r1.bind = node03
a1.sources.r1.port =41415

#定义channels
a1.channels.c1.type = memory
a1.channels.c1.capacity = 20000
a1.channels.c1.transactionCapacity = 10000

#定义sink
a1.sinks.k1.type = hdfs
a1.sinks.k1.hdfs.path=hdfs://node01:8020/source/logs/%{type}/%Y%m%d
a1.sinks.k1.hdfs.filePrefix =events
a1.sinks.k1.hdfs.fileType = DataStream
a1.sinks.k1.hdfs.writeFormat = Text
#时间类型
a1.sinks.k1.hdfs.useLocalTimeStamp = true
#生成的文件不按条数生成
a1.sinks.k1.hdfs.rollCount = 0
#生成的文件按时间生成
a1.sinks.k1.hdfs.rollInterval = 30
#生成的文件按大小生成
a1.sinks.k1.hdfs.rollSize  = 10485760
#批量写入hdfs的个数
a1.sinks.k1.hdfs.batchSize = 10000
#flume操作hdfs的线程数(包括新建,写入等)
a1.sinks.k1.hdfs.threadsPoolSize=10
#操作hdfs超时时间
a1.sinks.k1.hdfs.callTimeout=30000

#组装source、channel、sink
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1
采集端文件生成脚本
  • 在node01与node02上面开发shell脚本,模拟数据生成
cd /kkb/install/shells
vim server.sh
  • 内容如下
#!/bin/bash
while true
do  
 date >> /kkb/install/taillogs/access.log; 
 date >> /kkb/install/taillogs/web.log;
 date >> /kkb/install/taillogs/nginx.log;
  sleep 0.5;
done
  • node01、node02给脚本添加可执行权限
chmod u+x server.sh
顺序启动服务
  • node03启动flume实现数据收集
cd /kkb/install/apache-flume-1.9.0-bin/
bin/flume-ng agent -c conf -f conf/avro_source_hdfs_sink.conf -name a1 -Dflume.root.logger=DEBUG,console
  • node01与node02启动flume实现数据监控
cd /kkb/install/apache-flume-1.9.0-bin/
bin/flume-ng agent -c conf -f conf/exec_source_avro_sink.conf -name a1 -Dflume.root.logger=DEBUG,console
  • node01与node02启动生成文件脚本
cd /kkb/install/shells
sh server.sh
  • 查看hdfs目录/source/logs

Flume综合案例之自定义拦截器使用

案例需求:

  • 在数据采集之后,通过Flume的拦截器,实现将无效的JSON格式的消息过滤掉。

实现步骤

第一步:创建maven java工程,导入jar包
<dependencies>
    <dependency>
        <groupId>org.apache.flume</groupId>
        <artifactId>flume-ng-core</artifactId>
        <version>1.9.0</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
                <!--    <verbal>true</verbal>-->
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.1.1</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass></mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
第二步:自定义flume的拦截器

新建package com.niit.flume.interceptor

新建类及内部类,分别是JsonInterceptorMyBuilder

package com.niit.flume.interceptor;

import org.apache.commons.codec.Charsets;
import org.apache.commons.lang.StringUtils;
import org.apache.flume.Context;
import org.apache.flume.Event;
import org.apache.flume.interceptor.Interceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Author: deLucia
 * @Date: 2021/6/2
 * @Version: 1.0
 * @Description:
 */
public class JsonInterceptor implements Interceptor {
    private static final Logger LOG = LoggerFactory.getLogger(JsonInterceptor.class);
    private String tag = "";

    public JsonInterceptor(String tag) {
        this.tag = tag;
    }

    @Override
    public void initialize() {

    }

    /**
     * 过滤JSON格式之外的数据 {“key":value, {...}}
     * @param event
     * @return
     */
    @Override
    public Event intercept(Event event) {
        String line = new String(event.getBody(), Charsets.UTF_8);
        line = line.trim();
        if (StringUtils.isBlank(line)) {
            return null;
        }

        // {..}
        if (line.startsWith("{") && line.endsWith("}")) {

            Map<String, String> headers = event.getHeaders();
            headers.put("tag", tag);
            return event;

        } else {
            LOG.warn("Not Valid JSON: " + line);
            return null;
        }
    }

    @Override
    public List<Event> intercept(List<Event> list) {
        List<Event> out = new ArrayList<Event>();
        for (Event event : list) {
            Event outEvent = intercept(event);
            if (outEvent != null) {
                out.add(outEvent);
            }
        }
        return out;
    }

    @Override
    public void close() {

    }
    /**
     * 相当于自定义Interceptor的工厂类
     * 在flume采集配置文件中通过指定该Builder来创建Interceptor对象
     *
     * @author
     */
    public static class MyBuilder implements Interceptor.Builder {

        private String tag;

        @Override
        public void configure(Context context) {
            //从flume的配置文件中获得拦截器的“tag”属性值
            this.tag = context.getString("tag", "").trim();
        }

        /*
         * @see org.apache.flume.interceptor.Interceptor.Builder#build()
         */
        @Override
        public JsonInterceptor build() {
            return new JsonInterceptor(tag);
        }
    }
}
第三步:打包上传服务器
  • 将我们的拦截器打成jar包放到主机名为hadoop100的服务器上的flume安装目录下的lib目录下
第四步:开发flume的配置文件

开发flume的配置文件

cd /opt/pkg/flume/conf/
vim nc-interceptor-logger.conf
  • 内容如下

记得将下边的i1.type根据自己的实际情况进行替换

#声明三种组件
a1.sources = r1
a1.channels = c1
a1.sinks = k1

#定义source信息
a1.sources.r1.type=netcat
a1.sources.r1.bind=localhost
a1.sources.r1.port=8888
#定义source的拦截器
a1.sources.r1.interceptors = i1
#根据自定义的拦截器,相应修改全类名及内部类名
a1.sources.r1.interceptors.i1.type =com.niit.flume.interceptor.JsonInterceptor$MyBuilder
## tag的内容将被设置到消息头中
a1.sources.r1.interceptors.i1.tag = json_event

#定义sink信息
a1.sinks.k1.type=logger

#定义channel信息
a1.channels.c1.type=memory

#绑定在一起
a1.sources.r1.channels=c1
a1.sinks.k1.channel=c1
第五步:运行FLume Agent

同时开启INFO日志级别

[hadoop@hadoop100 conf]$ bin/flume-ng agent -c conf/ -f conf/nc_interceptor_logger.conf -n a1 -Dflume.root.logger=INFO,console
第六步:简单测试

通过netcat客户端发送数据

[hadoop@hadoop100 ~]$ nc localhost 8888
asd
dsa
{"OK
OK                                                                             {
OK
OK
{"key":123}
OK

查看flume的agent的日志信息如下

2021-05-26 14:40:12,233 (lifecycleSupervisor-1-4) [INFO - org.apache.flume.source.NetcatSource.start(NetcatSource.java:155)] Source starting
2021-05-26 14:40:17,326 (lifecycleSupervisor-1-4) [INFO - org.apache.flume.source.NetcatSource.start(NetcatSource.java:166)] Created serverSocket:sun.nio.ch.ServerSocketChannelImpl[/127.0.0.1:8888]
2021-05-26 14:40:20,952 (netcat-handler-0) [WARN - com.niit.flume.interceptor.JsonInterceptor.intercept(JsonInterceptor.java:48)] Invalid json format event !
2021-05-26 14:40:20,953 (netcat-handler-0) [WARN - com.niit.flume.interceptor.JsonInterceptor.intercept(JsonInterceptor.java:48)] Invalid json format event !
2021-05-26 14:40:24,109 (netcat-handler-0) [WARN - com.niit.flume.interceptor.JsonInterceptor.intercept(JsonInterceptor.java:48)] Invalid json format event !
2021-05-26 14:40:24,909 (netcat-handler-0) [WARN - com.niit.flume.interceptor.JsonInterceptor.intercept(JsonInterceptor.java:48)] Invalid json format event !
2021-05-26 14:40:36,895 (SinkRunner-PollingRunner-DefaultSinkProcessor) [INFO - org.apache.flume.sink.LoggerSink.process(LoggerSink.java:95)] Event: { headers:{tag=json_event} body: 7B 22 6B 65 79 22 3A 31 32 33 7D                {"key":123} }

Views: 124

Index