{"id":9040,"date":"2018-02-22T13:02:55","date_gmt":"2018-02-22T13:02:55","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=9040"},"modified":"2021-05-09T13:08:27","modified_gmt":"2021-05-09T07:38:27","slug":"apache-flume-channel","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/","title":{"rendered":"Apache Flume Channel | Types of Channels in Flume"},"content":{"rendered":"

It’s time to explore different Apache Flume Channel with properties and examples.<\/p>\n

In this article, we will explore different Flume channels. The article describes various flume channels like memory channel, JDBC channel, Kafka channel, File channel, and spillable memory channel.<\/p>\n

The article also covers the Pseudo transactional channel and custom channel. You will explore various flume channels along with properties and examples.<\/p>\n

Let us first see a short introduction to the Flume channel.<\/p>\n

Introduction to Flume channel<\/h2>\n

Flume channel is one of the components of a Flume agent. It sits in between flume sources and flume sinks. Channels ensure no loss of data in Flume. Sources write data to the Flume channel.<\/p>\n

The data written to the Flume channel are consumed by Flume sinks. A flume sink can read events from only one channel while multiple sinks can read data from the same channel. They are transactional.<\/p>\n

In simple words, it is a passive store that stores data received from sources until the data is consumed by the sink. They are the repositories where the flume events are staged on an agent.
\nIn Flume channels, the Sources adds the events and the Sinks removes it.<\/p>\n

Let us now explore different Flume channels.<\/p>\n

1. Memory Channel<\/h3>\n

The memory channel is an in-memory queue where the sources write events to its tail and sinks read the events from its head. The memory channel stores the event written to it by the sources on the heap. We can configure the max size.<\/p>\n

Since it stores all data in memory thus provides high throughput. It is best for those flows where data loss is not a concern. It is not suitable for the data flows where data loss is concerned.<\/p>\n

Some of the properties for Memory channel are:<\/p>\n\n\n\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n<\/td>\nThe component type name must be memory.\u00a0<\/span><\/td>\n<\/tr>\n
capacity<\/span><\/td>\n100<\/span><\/td>\nIt specifies the maximum number of events the channel can store.<\/span><\/td>\n<\/tr>\n
transactionCapacity<\/span><\/td>\n<\/td>\nIt specifies the maximum number of events that the channel will take from a flume source or give it to a flume sink per transaction.\u00a0\u00a0<\/span><\/td>\n<\/tr>\n
keep-alive<\/span><\/td>\n3<\/span><\/td>\nThis property specifies the timeout in seconds for adding or removing an event.<\/span><\/td>\n<\/tr>\n
byteCapacityBufferPercentage<\/span><\/td>\n20<\/span><\/td>\nIt defines the percentage of buffer in between the byteCapacity and the estimated total size of all flume events in the channel,in order to account for data in the headers.\u00a0<\/span><\/td>\n<\/tr>\n
byteCapacity<\/span><\/td>\n<\/td>\nIt specifies the maximum total <\/span>bytes<\/b> of memory which are\u00a0 allowed as a sum of all flume events in the memory channel. The implementation only counts for the Event body, which is the reason for providing configuration parameters of the <\/span>byteCapacityBufferPercentage<\/span> as well.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Example for Memory channel for agent named agent1 and channel ch1:<\/p>\n

agent1.channels = ch1\r\nagent1.channels.ch1.type = memory\r\nagent1.channels.ch1.capacity = 10000\r\nagent1.channels.ch1.transactionCapacity = 10000\r\nagent1.channels.ch1.byteCapacityBufferPercentage = 20\r\nagent1.channels.ch1.byteCapacity = 800000\r\n<\/pre>\n
2. JDBC Channel<\/h3>\n
The JDBC channel stores the Flume events on persistent storage that is backed by a database. It currently supports embedded Derby.
\nIt is best for the flows where recoverability is important.<\/p>\n
Some of the properties for JDBC channel are:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be jdbc.\u00a0<\/span><\/td>\n<\/tr>\n
db.type<\/span><\/td>\nDERBY<\/span><\/td>\nIt specifies the Database vendor. It needs to be DERBY.<\/span><\/td>\n<\/tr>\n
driver.class<\/span><\/td>\norg.apache.derby.jdbc.EmbeddedDriver<\/span><\/td>\nIt specifies the Class for vendor\u2019s JDBC driver\u00a0<\/span><\/td>\n<\/tr>\n
driver.url<\/span><\/td>\n(constructed from other properties)<\/span><\/td>\nIt specifies the JDBC connection URL<\/span><\/td>\n<\/tr>\n
db.username<\/span><\/td>\n\u201csa\u201d<\/span><\/td>\nIt specifies the User id for db connection<\/span><\/td>\n<\/tr>\n
db.password<\/span><\/td>\n–<\/span><\/td>\nIt specifies the password for db connection<\/span><\/td>\n<\/tr>\n
connection.properties.file<\/span><\/td>\n–<\/span><\/td>\nIt specifies the JDBC Connection property file path<\/span><\/td>\n<\/tr>\n
maximum.capacity<\/span><\/td>\n0 (unlimited)<\/span><\/td>\nIt specifies the maximum number of events in the channel<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Example for JDBC channel for agent named agent1 and channel ch1:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = jdbc\r\n<\/pre>\n
3. Kafka Channel<\/h3>\n
The Kafka channel stores flume events in a Kafka cluster which must be installed separately.<\/p>\n
The Kafka channel provides high availability and replication. If the agent or a Kafka broker crashes, then the flume events are immediately available to the other sinks<\/p>\n
We can use Kafka channel for multiple scenarios:<\/p>\n
a) With Flume source and sink<\/h4>\n
This provides a highly available and reliable channel for events.<\/p>\n
b) With Flume source and interceptor but no sink<\/h4>\n
This allows writing of Flume events into a Kafka topic, for use by other applications.<\/p>\n
c) With Flume sink, but no source<\/h4>\n
This is a low-latency, fault-tolerant way of sending flume events from Kafka to Flume sinks like HDFS, HBase or Solr<\/p>\n
Presently it supports Kafka server 0.10.1.0 releases or higher.<\/p>\n
The testing was done up to Kafka 2.0.1 which was the highest Kafka version during release.<\/p>\n
The configuration parameters were organized as such:<\/strong><\/p>\n
1. Configuration values which are related to the channel generically were applied at the channel config level.<\/p>\n
For eg: agent1.channel.ch1.type =<\/p>\n
2. Configuration values which are related to Kafka or how the Channels operates were prefixed with \u201ckafka.\u201d<\/p>\n
Foreg: agent1.channels.ch1.kafka.topic and agent1.channels.ch1.kafka.bootstrap.servers.<\/p>\n
3. The properties which are specific to the producer\/consumer are prefixed as kafka.producer or kafka.consumer<\/p>\n
4. Wherever possible, the Kafka parameter names are used
\nFor eg: bootstrap.servers and sacks.<\/p>\n
Some properties for Kafka are:<\/p>\n\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be <\/span>org.apache.flume.channel.kafka.KafkaChannel<\/span>.\u00a0<\/span><\/td>\n<\/tr>\n
kafka.bootstrap.servers<\/td>\n–<\/span><\/td>\nIt specifies the list of brokers in the Kafka cluster used by the channel.<\/span><\/p>\n
It can be a partial list of brokers. We recommend at least two for HA. The format is a comma-separated list of hostname:port<\/span><\/td>\n<\/tr>\n
kafka.topic<\/span><\/td>\nflume-channel<\/span><\/td>\nIt specifies the Kafka topic which the Kafka channel will use<\/span><\/td>\n<\/tr>\n
kafka.consumer.group.id<\/span><\/td>\nflume<\/span><\/td>\nIt specifies the Consumer group ID the channel uses to register with Kafka. Multiple channels must use the same topic and group to ensure that when one agent fails another can get the data Note: Having non-channel consumers with the same ID can lead to data loss.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Example for Kafka channel for agent named agent1 and channel ch1:<\/p>\n
agent1.channels.ch1.type= org.apache.flume.channel.kafka.KafkaChannel\r\nagent1.channels.ch1.kafka.bootstrap.servers= kafka-1:9092,kafka-2:9092,kafka-3:9092\r\nagent1.channels.ch1.kafka.topic = channel1\r\nagent1.channels.ch1.kafka.consumer.group.id = flume-consumer\r\n<\/pre>\n
4. File Channel<\/h3>\n
It is the Flume\u2019s persistent channel. File channel writes out all the flume events to the disk. It does not lose data even when the process or machine shuts down or crashes.<\/p>\n
This channel ensures that any events which are committed into the channel are removed from it only when a sink consumes the events and commits the transaction. It does this even if the machine\/agent crashed and was restarted.<\/p>\n
The file channel is highly concurrent and handles several flume sources and sinks at the same time.<\/p>\n
It is best for flows where we require data durability and can’t tolerate data loss.
\nAs this channel writes data onto the disk, so it does not lose any data even on crash or failure. This is also advantageous for having a very large capacity, especially when compared to the Memory Channel.<\/p>\n
Some properties for the File channel are:<\/p>\n\n\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be file.<\/span><\/td>\n<\/tr>\n
checkpointDir<\/span><\/td>\n~\/.flume\/file-channel\/checkpoint<\/span><\/td>\nIt specifies the directory where checkpoint file will be stored<\/span><\/td>\n<\/tr>\n
dataDirs<\/span><\/td>\n~\/.flume\/file-channel\/data<\/span><\/td>\nIt specifies the comma-separated list of directories for storing log files.<\/span> Use of multiple directories on the separate disks improves the\u00a0 file channel performance.<\/span><\/td>\n<\/tr>\n
transactionCapacity<\/span><\/td>\n10000<\/span><\/td>\nIt specifies the maximum size of transaction supported by the channel<\/span><\/td>\n<\/tr>\n
capacity<\/span><\/td>\n1000000<\/span><\/td>\nIt specifies the maximum capacity of the channel<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Example for File channel for agent named agent1 and channel ch1:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = file\r\nagent1.channels.ch1.checkpointDir = \/mnt\/flume\/checkpoint\r\nagent1.channels.ch1.dataDirs = \/mnt\/flume\/data\r\n<\/pre>\n
5. Spillable Memory Channel<\/h3>\n
The Spillable memory channel stores events in an in-memory queue and on disk. The in-memory queue is the primary store and the disk is the overflow.
\nUsing the embedded File channel, the disk store is managed.<\/p>\n
In case when the in-memory queue gets full then the File channel stores the additional incoming events.<\/p>\n
It is best for flows that require high throughput of the memory channel during normal operation, and at the same time, the flow requires the larger capacity of the file channel for good tolerance of intermittent flume sink side outages or drop in drain rates.<\/p>\n
During the agent crash or restart, only the flume events which are stored on disk are recovered when the flume agent comes online. The Spillable memory channel is currently experimental and is not recommended for use in the production.<\/p>\n
Some of the properties for the Spillable memory channel are:<\/p>\n\n\n\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be <\/span>SPILLABLEMEMORY<\/b>.<\/span><\/td>\n<\/tr>\n
memoryCapacity<\/span><\/td>\n10000<\/span><\/td>\nIt specifies the maximum number of events stored in-memory queue. Set this to zero if you want to disable the use of an in-memory queue.<\/span><\/td>\n<\/tr>\n
overflowCapacity<\/span><\/td>\n100000000<\/span><\/td>\nIt specifies the maximum number of events stored in the overflow disk. Set this to zero if you want to disable the use of overflow disk (i.e file channel)<\/span><\/td>\n<\/tr>\n
avgEventSize<\/span><\/td>\n500<\/span><\/td>\nIt specifies the estimated average size of events (in bytes) which are\u00a0 going into the channel<\/span><\/td>\n<\/tr>\n
byteCapacityBufferPercentage<\/span><\/td>\n20<\/span><\/td>\nIt defines the percentage of buffer in between the byteCapacity and the estimated total size of all flume events in the channel,in order to account for data in the headers.\u00a0<\/span><\/td>\n<\/tr>\n
byteCapacity<\/span><\/td>\n<\/td>\nIt specifies the maximum total <\/span>bytes<\/b> of memory which are\u00a0 allowed as a sum of all flume events in the memory channel. The implementation only counts for the Event body, which is the reason for providing configuration parameters of the <\/span>byteCapacityBufferPercentage<\/span> as well.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Example for Spillable memory channel for agent named agent1 and channel ch1:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = SPILLABLEMEMORY\r\nagent1.channels.ch1.memoryCapacity = 10000\r\nagent1.channels.ch1.overflowCapacity = 1000000\r\nagent1.channels.ch1.byteCapacity = 800000\r\nagent1.channels.ch1.checkpointDir = \/mnt\/flume\/checkpoint\r\nagent1.channels.ch1.dataDirs = \/mnt\/flume\/data\r\n<\/pre>\n
Program for disabling the use of in-memory queue and functioning like a file channel:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = SPILLABLEMEMORY\r\nagent1.channels.ch1.memoryCapacity = 0\r\nagent1.channels.ch1.overflowCapacity = 1000000\r\nagent1.channels.ch1.checkpointDir = \/mnt\/flume\/checkpoint\r\nagent1.channels.ch1.dataDirs = \/mnt\/flume\/data\r\n<\/pre>\n
Example for disabling use of overflow disk that is file channel and functioning purely like a in-memory channel:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = SPILLABLEMEMORY\r\nagent1.channels.ch1.memoryCapacity = 100000\r\nagent1.channels.ch1.overflowCapacity = 0\r\n<\/pre>\n
6. Pseudo Transactional Channel<\/h3>\n
It is designed only for testing purposes. It must not be used in production.<\/p>\n
Some of the properties for Pseudo transactional channel are:<\/p>\n\n\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be <\/span>org.apache.flume.channel.PseudoTxnMemoryChanne<\/b>l<\/span>.<\/span><\/td>\n<\/tr>\n
capacity<\/span><\/td>\n50<\/span><\/td>\nIt specifies the max number of events the channel can store.<\/span><\/td>\n<\/tr>\n
keep-alive<\/span><\/td>\n3<\/span><\/td>\nIt specifies the timeout in seconds for adding or removing an event<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
7. Custom Channel<\/h3>\n
It is our own implementation for the Channel interface. We must include the custom channel\u2019s class and its dependencies in the agent’s classpath while starting the Flume agent. The custom channel type must be its FQCN.<\/p>\n
Some of the property for the custom channel is:<\/p>\n\n\n\n\n
Property Name<\/strong><\/td>\nDefault values\u00a0<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
type<\/td>\n–<\/span><\/td>\nThe component type name must be FQCN.\u00a0<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Example for Custom channel for agent named agent1 and channel ch1:<\/p>\n
agent1.channels = ch1\r\nagent1.channels.ch1.type = org.example.MyChannel\r\n<\/pre>\n
Summary<\/h2>\n
I hope after reading this article you clearly understood different channels in the flume. Now you can set configuration properties of different flume channels.<\/p>\n
The article has explained Flume channels like memory channel, Kafka channel, file channel, pseudo transactional channel, JDBC channel, custom channel, and spillable memory channel.<\/p>\n","protected":false},"excerpt":{"rendered":"
It’s time to explore different Apache Flume Channel with properties and examples. In this article, we will explore different Flume channels. The article describes various flume channels like memory channel, JDBC channel, Kafka channel,...<\/p>\n","protected":false},"author":6,"featured_media":78370,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[21],"tags":[768,769,771,777,2458,3221,4670,4809,4819,4824,4829,4830,7765,7855,8637],"class_list":["post-9040","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-flume","tag-apache-flume-channel","tag-apache-flume-example","tag-apache-flume-installation","tag-apache-flume-tutorial","tag-channel-in-flume","tag-custom-channel","tag-file-channel","tag-flume-channels","tag-flume-file-channel","tag-flume-interceptor","tag-flume-kafka","tag-flume-kafka-channel","tag-jdbc-channel","tag-kafka-channel","tag-memory-channel"],"yoast_head":"\nApache Flume Channel | Types of Channels in Flume - DataFlair<\/title>\n<meta name=\"description\" content=\"Apache Flume channel-Types of Channel in Flume,Memory Channel,JDBC Channel,Kafka Channel,Flume File Channel,Pseudo Flume Channel,Custom Channel in flume,\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Apache Flume Channel | Types of Channels in Flume - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Apache Flume channel-Types of Channel in Flume,Memory Channel,JDBC Channel,Kafka Channel,Flume File Channel,Pseudo Flume Channel,Custom Channel in flume,\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-02-22T13:02:55+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-05-09T07:38:27+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"802\" \/>\n\t<meta property=\"og:image:height\" content=\"420\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Apache Flume Channel | Types of Channels in Flume - DataFlair","description":"Apache Flume channel-Types of Channel in Flume,Memory Channel,JDBC Channel,Kafka Channel,Flume File Channel,Pseudo Flume Channel,Custom Channel in flume,","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/","og_locale":"en_US","og_type":"article","og_title":"Apache Flume Channel | Types of Channels in Flume - DataFlair","og_description":"Apache Flume channel-Types of Channel in Flume,Memory Channel,JDBC Channel,Kafka Channel,Flume File Channel,Pseudo Flume Channel,Custom Channel in flume,","og_url":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-02-22T13:02:55+00:00","article_modified_time":"2021-05-09T07:38:27+00:00","og_image":[{"width":802,"height":420,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89"},"headline":"Apache Flume Channel | Types of Channels in Flume","datePublished":"2018-02-22T13:02:55+00:00","dateModified":"2021-05-09T07:38:27+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/"},"wordCount":1771,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg","keywords":["Apache Flume Channel","apache flume example","Apache flume installation","Apache Flume Tutorial","channel in Flume","Custom Channel","File Channel","Flume Channels","flume file channel","flume interceptor","flume kafka","Flume Kafka Channel","JDBC Channel","Kafka Channel","Memory Channel"],"articleSection":["Flume Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/","url":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/","name":"Apache Flume Channel | Types of Channels in Flume - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg","datePublished":"2018-02-22T13:02:55+00:00","dateModified":"2021-05-09T07:38:27+00:00","description":"Apache Flume channel-Types of Channel in Flume,Memory Channel,JDBC Channel,Kafka Channel,Flume File Channel,Pseudo Flume Channel,Custom Channel in flume,","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/apache-flume-channel\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/apache-flume-channels.jpg","width":802,"height":420,"caption":"apache flume channels"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/apache-flume-channel\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Flume Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/flume\/"},{"@type":"ListItem","position":3,"name":"Apache Flume Channel | Types of Channels in Flume"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"The DataFlair Team provides industry-driven content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our expert educators focus on delivering value-packed, easy-to-follow resources for tech enthusiasts and professionals.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam2\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/9040","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=9040"}],"version-history":[{"count":4,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/9040\/revisions"}],"predecessor-version":[{"id":92685,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/9040\/revisions\/92685"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/78370"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=9040"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=9040"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=9040"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}