<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta http-equiv="X-UA-Compatible" content="IE=edge"/><title>Blog · Apache Pulsar</title><meta name="viewport" content="width=device-width, initial-scale=1.0"/><meta name="generator" content="Docusaurus"/><meta name="description" content=""/><meta name="docsearch:language" content="en"/><meta property="og:title" content="Blog · Apache Pulsar"/><meta property="og:type" content="website"/><meta property="og:url" content="https://pulsar.apache.org/"/><meta property="og:description" content=""/><meta name="twitter:card" content="summary"/><meta name="twitter:image" content="https://pulsar.apache.org/img/pulsar.svg"/><link rel="shortcut icon" href="/img/pulsar.ico"/><link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/atom-one-dark.min.css"/><link rel="alternate" type="application/atom+xml" href="https://pulsar.apache.org/blog/atom.xml" title="Apache Pulsar Blog ATOM Feed"/><link rel="alternate" type="application/rss+xml" href="https://pulsar.apache.org/blog/feed.xml" title="Apache Pulsar Blog RSS Feed"/><link rel="stylesheet" href="/css/code-blocks-buttons.css"/><script type="text/javascript" src="https://buttons.github.io/buttons.js"></script><script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.0/clipboard.min.js"></script><script type="text/javascript" src="/js/custom.js"></script><script src="/js/scrollSpy.js"></script><link rel="stylesheet" href="/css/main.css"/><script src="/js/codetabs.js"></script></head><body class="blog"><div class="fixedHeaderContainer"><div class="headerWrapper wrapper"><header><a href="/en"><img class="logo" src="/img/pulsar.svg" alt="Apache Pulsar"/></a><a href="/en/versions"><h3>2.10.0</h3></a><div class="navigationWrapper navigationSlider"><nav class="slidingNav"><ul class="nav-site nav-site-internal"><li class=""><a href="/docs/en/getting-started-standalone" target="_self">Docs</a></li><li class=""><a href="/en/download" target="_self">Download</a></li><li class=""><a href="/docs/en/client-libraries" target="_self">Clients</a></li><li class=""><a href="#restapis" target="_self">REST APIs</a></li><li class=""><a href="#cli" target="_self">Cli</a></li><li class="siteNavGroupActive siteNavItemActive"><a href="/blog/" target="_self">Blog</a></li><li class=""><a href="#community" target="_self">Community</a></li><li class=""><a href="#apache" target="_self">Apache</a></li><li class=""><a href="https://pulsar-next.staged.apache.org/" target="_self">New Website (Beta)</a></li><span><li><a id="languages-menu" href="#"><img class="languages-icon" src="/img/language.svg" alt="Languages icon"/>English</a><div id="languages-dropdown" class="hide"><ul id="languages-dropdown-items"><li><a href="/ja">日本語</a></li><li><a href="/fr">Français</a></li><li><a href="/ko">한국어</a></li><li><a href="/zh-CN">中文</a></li><li><a href="/zh-TW">繁體中文</a></li><li><a href="https://crowdin.com/project/apache-pulsar" target="_blank" rel="noreferrer noopener">Help Translate</a></li></ul></div></li><script>
        const languagesMenuItem = document.getElementById("languages-menu");
        const languagesDropDown = document.getElementById("languages-dropdown");
        languagesMenuItem.addEventListener("click", function(event) {
          event.preventDefault();

          if (languagesDropDown.className == "hide") {
            languagesDropDown.className = "visible";
          } else {
            languagesDropDown.className = "hide";
          }
        });
      </script></span></ul></nav></div></header></div></div><div class="navPusher"><div class="docMainWrapper wrapper"><div class="docsNavContainer" id="docsNav"><nav class="toc"><div class="toggleNav"><section class="navWrapper wrapper"><div class="navBreadcrumb wrapper"><div class="navToggle" id="navToggler"><div class="hamburger-menu"><div class="line1"></div><div class="line2"></div><div class="line3"></div></div></div><h2><i>›</i><span>Recent Posts</span></h2><div class="tocToggler" id="tocToggler"><i class="icon-toc"></i></div></div><div class="navGroups"><div class="navGroup"><h3 class="navGroupCategoryTitle">Recent Posts</h3><ul class=""><li class="navListItem"><a class="navItem" href="/blog/2022/05/11/whats-new-in-pulsar-210">What’s New in Apache Pulsar 2.10</a></li><li class="navListItem"><a class="navItem" href="/blog/2022/05/11/apache-pulsar-community-welcomes-500th-contributor">The Apache Pulsar Community Welcomes 500th Contributor!</a></li><li class="navListItem"><a class="navItem" href="/blog/2022/04/08/Apache-Pulsar-2-9-2">What’s New in Apache Pulsar 2.9.2</a></li><li class="navListItem"><a class="navItem" href="/blog/2021/12/14/Apache-Pulsar-2-7-4">What’s New in Apache Pulsar 2.7.4</a></li><li class="navListItem"><a class="navItem" href="/blog/2021/12/11/Log4j-CVE">Log4j2 Zero Day vulnerability (CVE-2021-44228)</a></li></ul></div></div></section></div><script>
            var coll = document.getElementsByClassName('collapsible');
            var checkActiveCategory = true;
            for (var i = 0; i < coll.length; i++) {
              var links = coll[i].nextElementSibling.getElementsByTagName('*');
              if (checkActiveCategory){
                for (var j = 0; j < links.length; j++) {
                  if (links[j].classList.contains('navListItemActive')){
                    coll[i].nextElementSibling.classList.toggle('hide');
                    coll[i].childNodes[1].classList.toggle('rotate');
                    checkActiveCategory = false;
                    break;
                  }
                }
              }

              coll[i].addEventListener('click', function() {
                var arrow = this.childNodes[1];
                arrow.classList.toggle('rotate');
                var content = this.nextElementSibling;
                content.classList.toggle('hide');
              });
            }

            document.addEventListener('DOMContentLoaded', function() {
              createToggler('#navToggler', '#docsNav', 'docsSliderActive');
              createToggler('#tocToggler', 'body', 'tocActive');

              var headings = document.querySelector('.toc-headings');
              headings && headings.addEventListener('click', function(event) {
                var el = event.target;
                while(el !== headings){
                  if (el.tagName === 'A') {
                    document.body.classList.remove('tocActive');
                    break;
                  } else{
                    el = el.parentNode;
                  }
                }
              }, false);

              function createToggler(togglerSelector, targetSelector, className) {
                var toggler = document.querySelector(togglerSelector);
                var target = document.querySelector(targetSelector);

                if (!toggler) {
                  return;
                }

                toggler.onclick = function(event) {
                  event.preventDefault();

                  target.classList.toggle(className);
                };
              }
            });
        </script></nav></div><div class="container mainContainer postContainer blogContainer"><div class="wrapper"><div class="posts"><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/12/24/Apache-Pulsar-2-7-0">Apache Pulsar 2.7.0</a></h1><p class="post-meta">December 24, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/lipenghui6" target="_blank" rel="noreferrer noopener">Penghui Li</a></p></div></header><article class="post-content"><div><span><p>We are very glad to see the Apache Pulsar community has successfully released the wonderful 2.7.0 version after accumulated hard work. It is a great milestone for this fast-growing project and the whole Pulsar community. This is the result of a huge effort from the community, with over 450 commits and a long list of new features, improvements, and bug fixes.</p>
<p>Here is a selection of the most interesting and major features added to Pulsar 2.7.0.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/12/24/Apache-Pulsar-2-7-0">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/11/09/Apache-Pulsar-2-6-2">Apache Pulsar 2.6.2</a></h1><p class="post-meta">November 9, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/wolf4j1" target="_blank" rel="noreferrer noopener">Xiaolong Ran</a></p></div></header><article class="post-content"><div><span><p>We are excited to see that the Apache Pulsar community has successfully released the 2.6.2 version after a lot of hard work. It is a great milestone for this fast-growing project and the Pulsar community. 2.6.2 is the result of a big effort from the community, with over 154 commits and a long list of improvements and bug fixes.</p>
<p>Here are some highlights and major features added in Pulsar 2.6.2.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/11/09/Apache-Pulsar-2-6-2">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/11/04/pulsar-summit-asia-schedule">Pulsar Summit Asia 2020 Schedule is Now Online</a></h1><p class="post-meta">November 4, 2020</p><div class="authorBlock"><p class="post-authorName"><a target="_blank" rel="noreferrer noopener">Carolyn King, Dianjin Wang</a></p></div></header><article class="post-content"><div><span><p>The Pulsar Summit is a global conference dedicated to sharing best practices, project updates, and insights across the Apache Pulsar community. Pulsar’s inaugural global summit, the <a href="https://pulsar-summit.org/en/event/virtual-conference-2020">Pulsar Summit Virtual Conference 2020</a>, took place in June 2020 and featured more than 30 sessions from top Pulsar experts, developers and thought-leaders from companies such as Salesforce, Verizon Media, and Splunk, and the conference attracted 600+ attendees.</p>
<p>The rapid adoption of Apache Pulsar over the past few years has led to a high demand for Pulsar events. Today, StreamNative, a cloud-native event streaming company powered by Apache Pulsar, and also the host of <a href="https://pulsar-summit.org/en/event/asia-2020">Pulsar Summit Asia 2020</a>, announced more details on the upcoming event. Taking place on November 28th &amp; 29th, the two-day event will feature more than 30 live sessions by tech leads, open-source developers, software engineers, and software architects from <strong>Splunk, Yahoo! JAPAN, TIBCO, China Mobile, Tencent, Dada Group, KingSoft Cloud, Tuya Smart, and PingCAP</strong>, and will include sessions on Pulsar use cases, its ecosystem, operations, and technology deep dives.</p>
<p>See below for some of our featured sessions, which include both English and Mandarin tracks:</p>
<ul>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/how-splunk-is-using-pulsar-io">How Splunk is using Pulsar IO （English）</a> - In this talk, Jerry Peng, Principal Software Engineer at Splunk will share insights on Splunk’s evaluation and decision to adopt the Pulsar IO framework, details on how Splunk's DSP product leverages the Pulsar IO framework, and insights on batch sources, a feature that was recently added to Pulsar IO.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/apache–pulsar–at–yahoo–japan–adoption–operational–experiences–and–future">Apache Pulsar at Yahoo! JAPAN - Adoption, Operational Insights and the Future（English）</a> - In this talk, Nozomi Kurihara, Manager of the Messaging Platform team in Yahoo!Japan Corporation will share practical use cases of Apache Pulsar on production and insights on how to operate Apache Pulsar for large scale data streams.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/running-apache-pulsar-on-tencent-cloud-new-challenges-discussion-practice">Running Apache Pulsar on Tencent Cloud: New Challenges, Discussion, Practice (Mandarin)</a> - In this talk, Lin Lin, senior engineer of Tencent Cloud will address how Pulsar helps solve challenges with message queues on Tencent Cloud, such as dynamic expansion and contraction, and large numbers of partitions.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/how-bigo-builds-real-time-message-system-with-apache-pulsar-and-flink">How BIGO built a Real-Time Message System with Apache Pulsar and Flink (Mandarin) </a> - In this talk, Hang Chen, Leader of the Messaging Platform team from BIGO will share how BIGO leveraged Apache Pulsar to build a real-time message system and how they tune Pulsar for production.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/a-daredevil-story-apache-pulsar-in-zhaopin-com">A Daredevil' Story: Apache Pulsar in Zhaopin.com (Mandarin)</a> - In this talk, Shunli Gao, Senior Engineer at Zhaopin will share details on the development and future prospects of Apache Pulsar at Zhaopin.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/transactional-event-streaming-with-apache-pulsar">Transactional Event Streaming with Apache Pulsar (Mandarin)</a> - In this talk, Bo Cong, software engineer at StreamNative will share how Pulsar transaction works and how it is supported by Pulsar Functions.</li>
<li><a href="https://pulsar-summit.org/en/event/asia-2020/sessions/benchmarking-pulsar-vs-kafka-on-aws-process-results">Benchmarking Pulsar vs. Kafka on AWS: Process &amp; Results (Mandarin) </a> - In this talk, Penghui Li, the Apache Pulsar PMC member and software engineer at StreamNative will share the results of a benchmark test comparing Pulsar and Kafka that was run on AWS. The test ran Pulsar and Kafka under the same hardware environments on the write throughput, tailing read throughput, catchup read throughput, publish latency, and end-to-end latency of these two systems.</li>
</ul>
<p>More featured talks coming soon!</p>
<p>The number and diversity of the sessions demonstrate the accelerated adoption of Pulsar in PoC and production environments, as well as the rapid development in functionalities and diverse ecosystems. To learn more about how companies leverage Pulsar for <strong>messaging and event streaming, serverless computing, real-time analytics, event-driven applications, and mission-critical deployment management in production</strong>, <a href="https://hopin.to/events/pulsar-summit-asia-2020">RSVP</a> today!</p>
<p>We would like to say special thanks to the speakers for sharing their Pulsar expertise and experience with the community.</p>
<h1><a class="anchor" aria-hidden="true" id="about-apache-pulsar"></a><a href="#about-apache-pulsar" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>About Apache Pulsar</h1>
<p><a href="https://pulsar.apache.org">Apache Pulsar</a> is a cloud-native, distributed messaging and streaming platform that manages hundreds of billions of events per day. Pulsar was originally developed at Yahoo! as the unified messaging platform connecting critical Yahoo applications such as Yahoo Finance, Yahoo Mail, and Flickr to data.</p>
<p>Today, Pulsar is used for real-time event streaming use cases, including data pipelines, microservices, and stream processing. Its cloud-native architecture and built-in multi-tenancy differentiate it from its predecessors and uniquely position it as an enterprise-ready, event streaming platform. Pulsar's multi-layer architecture enables stability, reliability, scalability, and high performance, simplifies management and reduces costs. Its built-in multi-tenancy and geo-replication ensure that companies are able to build applications with disaster recovery.</p>
<h1><a class="anchor" aria-hidden="true" id="about-streamnative"></a><a href="#about-streamnative" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>About StreamNative</h1>
<p><a href="https://streamnative.io">StreamNative</a>, founded by the original developers of Apache Pulsar and Apache BookKeeper, enables organizations to build the next generation of messaging and event streaming applications. Leveraging Apache Pulsar and BookKeeper, we optimize for scalability and resiliency while reducing the overhead management and complexity required by incumbent technologies. We do this by offering Pulsar and StreamNative’s ‘products as a service’. StreamNative is building a world-class team that is passionate about building amazing products and committed to customer success.</p>
</span></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/09/01/pulsar-summit-asia-2020-cfp">Pulsar Summit Asia 2020 CFP is now open</a></h1><p class="post-meta">September 1, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/Jennife06125739" target="_blank" rel="noreferrer noopener">Jennifer Huang</a></p></div></header><article class="post-content"><div><span><p>The Pulsar Summit is an annual conference dedicated to the Apache Pulsar community. The summit brings together an international audience of CTOs/CIOs, developers, data architects, data scientists, Apache Pulsar committers/contributors, and the messaging and streaming community. Together, they share experiences, ideas, and insights on Pulsar and its growing community, and receive hands-on training sessions led by Pulsar experts.</p>
<p>After a very successful Pulsar Summit Virtual Conference in June, we have decided to present our Pulsar Summit Asia 2020 in the same way on November 28-29, 2020. The two-day conference will be free to attend! Are you interested in presenting? Suggested topics include Pulsar use cases, operations, technology deep dive, and ecosystem. CFP and registration are now open!</p>
<p><img src="../img/pulsar-summit-asia-2020.png" alt=""></p>
<h2><a class="anchor" aria-hidden="true" id="speak-at-pulsar-summit"></a><a href="#speak-at-pulsar-summit" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Speak at Pulsar Summit</h2>
<p>The opportunity to speak at the second global Pulsar Summit is a great chance to participate in the rapidly growing Apache Pulsar community. Join us for the opportunity to be on stage with top Pulsar thought-leaders, including Apache Pulsar PMC members Sijie Guo and Jia Zhai from <a href="https://streamnative.io/">StreamNative</a>, Penghui Li from Zhaopin.com, Nozomi Kurihara from <a href="https://about.yahoo.co.jp/">Yahoo Japan Corporation</a>, and other community leaders such as Dezhi Liu from <a href="https://www.tencent.com/en-us">Tencent</a>, Vincent Xie from <a href="https://www.bestpay.com.cn/">Orange Finance</a>. Proposals for speaker presentations are currently being accepted. Suggested topics include Pulsar use cases, operations, technology deep dive, and ecosystem. Submissions are open until <strong>October 14, 2020</strong>.</p>
<p>If you have questions about submitting a proposal, or want some feedback or advice in general, please do not hesitate to reach out to <a href="mailto:organizers@pulsar-summit.org">organizers@pulsar-summit.org</a>. We are happy to help out! Details are available on the <a href="https://pulsar-summit.org/en/event/asia-2020/cfp">CFP website</a>.</p>
<h2><a class="anchor" aria-hidden="true" id="dates-to-remember"></a><a href="#dates-to-remember" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Dates to remember</h2>
<ul>
<li>CFP opens: September 1, 2020</li>
<li>CFP closes: October 21, 2020 - 23:59 (CST: China Standard Time/UTC+8 time zone)</li>
<li>CFP notification: October 28, 2020</li>
<li>Schedule announcement: November 4, 2020</li>
</ul>
<h2><a class="anchor" aria-hidden="true" id="speaker-benefits"></a><a href="#speaker-benefits" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Speaker benefits</h2>
<p>When your speaking proposal is approved, you will enjoy the following benefits:</p>
<ul>
<li>The opportunity to expand your network and raise your profile in the Apache Pulsar community.</li>
<li>The chance to demonstrate your experience and deep knowledge in the rapidly growing event streaming space.</li>
<li>Your name, title, company, and bio will be featured on the Pulsar Summit Asia 2020 website.</li>
<li>Your session will be added to the Pulsar Summit YouTube Channel and promoted on Twitter and LinkedIn.</li>
<li>A professionally produced video of your presentation.</li>
</ul>
<h2><a class="anchor" aria-hidden="true" id="speaker-requirements"></a><a href="#speaker-requirements" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Speaker requirements</h2>
<p>In addition to your talk, we ask that you actively participate in promoting the event via your personal and company channels. These include posting on your Twitter, LinkedIn, WeChat, Weibo, blog and other channels. We would also like to work directly with your marketing team on co-marketing opportunities. These include, but are not limited to, posting to your company’s Twitter, LinkedIn, WeChat and other developer communities and sending a dedicated Pulsar Summit email to your company’s email list. Contact us at <a href="mailto:organizers@pulsar-summit.org">organizers@pulsar-summit.org</a> with any questions.</p>
<h2><a class="anchor" aria-hidden="true" id="registration"></a><a href="#registration" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Registration</h2>
<p>If you are interested in attending Pulsar Summit Asia 2020, please sign in Hopin and <a href="https://hopin.to/events/pulsar-summit-asia-2020">checkout our event</a>. Your ideas are very important to us, and we will prepare the content accordingly.</p>
<p>After you checkout the event in Hopin, you will be notified with the event update at the first time when announcing.</p>
<h2><a class="anchor" aria-hidden="true" id="sponsor-pulsar-summit"></a><a href="#sponsor-pulsar-summit" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Sponsor Pulsar Summit</h2>
<p>Pulsar Summit is a community run conference and your support is needed. Sponsoring this event will provide a great opportunity for your organization to further engage with the Apache Pulsar community. <a href="mailto:partners@pulsar-summit.org">Contact us</a> to learn more.</p>
<p>Help us make #PulsarSummit 2020 a big success by spreading the word and submitting your proposal! Follow us on Twitter (<a href="https://twitter.com/PulsarSummit">@pulsarsummit</a>) to receive the latest updates of the conference!</p>
<p>Hope to see you at Pulsar Summit Asia 2020!</p>
<h2><a class="anchor" aria-hidden="true" id="about-apache-pulsar"></a><a href="#about-apache-pulsar" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>About Apache Pulsar</h2>
<p>Apache Pulsar is a cloud-native, distributed messaging and streaming platform that manages hundreds of billions of events per day. Pulsar was originally developed and deployed inside Yahoo as the consolidated messaging platform connecting critical Yahoo applications such as Yahoo Finance, Yahoo Mail, and Flickr, to data. Pulsar was contributed to open source by Yahoo in 2016 and became a top-level Apache Software Foundation project in 2018.</p>
<h2><a class="anchor" aria-hidden="true" id="about-streamnative"></a><a href="#about-streamnative" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>About StreamNative</h2>
<p>StreamNative is the organizer of Pulsar Summit Asia 2020. StreamNative is enabling organizations to build the next generation of messaging and event streaming applications. Leveraging Apache Pulsar and BookKeeper, we optimize for scalability and resiliency while reducing the overhead management and complexity required by incumbent technologies. We do this by offering Pulsar and StreamNative’s &quot;products as a service&quot;. StreamNative is building a world-class team that is passionate about building amazing products and committed to customer success.</p>
</span></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/08/24/Pulsar-300-contributors">Apache Pulsar Celebrates 300 Contributors</a></h1><p class="post-meta">August 24, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/Jennife06125739" target="_blank" rel="noreferrer noopener">Jennifer Huang</a></p></div></header><article class="post-content"><div><span><p>Dear Pulsar community,</p>
<p>Over the last few years, the shift to real-time streaming technologies has bolstered the adoption of Pulsar and there has been a major increase in both the interest and adoption of Pulsar in 2020 alone. With Pulsar being sought out by companies developing messaging and event-streaming applications — from Fortune 100 companies to forward-thinking start-ups — the community is growing quickly.</p>
<p>This community growth has contributed to a new milestone for Pulsar - our <a href="https://github.com/apache/pulsar/graphs/contributors">300th contributor</a> to the Pulsar repository. This milestone is even more exciting given that we added 100 contributors in the last 8 months alone!</p>
<p>As many of you know, Apache Pulsar is a cloud-native messaging and event streaming platform that has experienced rapid growth since it was committed to open source in 2016. Pulsar graduated as a Top-Level Project (TLP) in September 2018, has launched 92 releases, attracted 5100+ commits from 300 contributors, received 6.5k+ stars, 1.6k+ forks, and 2.2k+ Slack users.</p>
<p>The influx of developers joining the Pulsar community is in large part due to the high market demand for next-generation messaging technologies, big-data insights, and real-time streaming. Top developers and industry leaders are joining the Pulsar community for the opportunity to help shape the future of this technology.</p>
<h2><a class="anchor" aria-hidden="true" id="community-events"></a><a href="#community-events" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Community Events</h2>
<p>To meet the high demand for education and training in the Pulsar community, the community has launched some key initiatives this year. We host weekly TGIP(Thank God It's Pulsar) training, which features Pulsar thought-leaders and Pulsar PMC Members. To meet global demand, we currently host two different weekly trainings. One <a href="https://www.youtube.com/watch?v=Vc_a2ppRzlI&amp;list=PLqRma1oIkcWhWAhKgImEeRiQi5vMlqTc-">TGIP training</a> runs on Pacific Time, and the other <a href="https://github.com/streamnative/tgip-cn">TGIP-CN training</a> runs on Beijing Time.</p>
<p>We also host monthly <a href="https://www.youtube.com/watch?v=mncXc_T6JkU&amp;list=PLqRma1oIkcWhfmUuJrMM5YIG8hjju62Ev">webinars</a> to bring together Pulsar and messaging community thought-leaders to share best practices, insights and product news. Thank <a href="https://twitter.com/merlimat">Matteo Merli</a>, <a href="https://twitter.com/addisonjh">Addison Higham</a>, Joe Francis, <a href="https://twitter.com/ShivjiJha">Shivji Kumar Jha</a>, <a href="https://twitter.com/DevinBost">Devin Bost</a>, <a href="https://twitter.com/PierreZ">Pierre Zemb</a>, <a href="https://twitter.com/jessetanderson">Jesse Anderson</a>, <a href="https://twitter.com/sijieg">Sijie Guo</a> and other speakers for contributing so much valuable knowledge.</p>
<p>This year also marked our first global summit, held in June 2020. Hosted by StreamNative and Splunk, the first-ever <a href="https://pulsar-summit.org/">Pulsar Summit Virtual Conference</a> featured 30+ talks from 20+ organizations. Thank all speakers for sharing your stories about Pulsar, and thank you to all of the attendees for joining the event.</p>
<p>We are excited to announce that we will be hosting Pulsar Summit Asia 2020 on November 28 and 29, and the call for presentations for this event will be coming soon.</p>
<h2><a class="anchor" aria-hidden="true" id="pulsar-adoption"></a><a href="#pulsar-adoption" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Pulsar Adoption</h2>
<p>In addition to the growth in contributors, we are excited to see accelerated adoption of Pulsar in PoC and production environments. Pulsar is helping companies globally to unlock the power of real-time data and to grow their businesses with efficiency and simplicity.</p>
<p>Key adoption stories illustrate Pulsar's ability to handle mission-critical applications. These include <a href="https://streamnative.io/success-stories/tencent">Tencent’s adoption</a> of Pulsar for its transactional billing system, which processes more than 10 billion transactions and 10+ TBs of data daily. <a href="https://www.youtube.com/watch?v=FXQvsHz_S1A">Verizon Media is another success story</a>, having operated Pulsar in production for more than 5 years, managing millions of write requests/second, and supporting the business across six global data centers. Most recently Splunk, which had used Kafka in production environments for years, <a href="https://www.youtube.com/watch?v=_q8s3_0-BRQ">adopted Pulsar for their new data processor</a>.</p>
<p>For more insights on Pulsar adoption, you can find a list for companies using or contributing to Apache Pulsar on <a href="http://pulsar.apache.org/en/powered-by/">Pulsar Powered by page</a>.</p>
<h2><a class="anchor" aria-hidden="true" id="ecosystem-development"></a><a href="#ecosystem-development" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Ecosystem Development</h2>
<p>Committed community partners have also contributed to key project advancements. Below, we look at two recent product launches.</p>
<h3><a class="anchor" aria-hidden="true" id="ovhcloud-helps-companies-move-from-kafka-to-pulsar"></a><a href="#ovhcloud-helps-companies-move-from-kafka-to-pulsar" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>OVHCloud Helps Companies Move from Kafka to Pulsar</h3>
<p>In March 2020, <a href="https://streamnative.io/blog/tech/2020-03-24-bring-native-kafka-protocol-support-to-apache-pulsar">OVHCloud and StreamNative launched Kafka-on-Pulsar (KoP)</a>, the result of the two companies working closely in partnership. <a href="https://github.com/streamnative/kop">KoP</a> enables Kafka users to migrate their existing Kafka applications and services to Pulsar without modifying the code. Although only recently released, KoP has already been adopted by several organizations and is being used in production environments. Moreover, KoP's availability is helping to expand Pulsar's adoption.</p>
<h3><a class="anchor" aria-hidden="true" id="china-mobile-helps-companies-move-from-rabbitmq-to-pulsar"></a><a href="#china-mobile-helps-companies-move-from-rabbitmq-to-pulsar" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>China Mobile Helps Companies Move from RabbitMQ to Pulsar</h3>
<p>In June 2020, <a href="https://streamnative.io/blog/tech/2020-06-15-announcing-aop-on-pulsar">China Mobile and StreamNative announced the launch of another major platform upgrade, AMQP-on-Pulsar (AoP)</a>. Similar to KoP, <a href="https://github.com/streamnative/aop">AoP</a> allows organizations currently using RabbitMQ (or other AMQP message brokers) to migrate existing applications and services to Pulsar without code modification. Again, this is a key initiative that will help drive the adoption and usage of Pulsar.</p>
<p>You can find a number of other connections and integrations, such as MQTT-on-Pulsar for building IoT applications, in the <a href="https://hub.streamnative.io/">StreamNative Hub</a>.</p>
<p>These events and initiatives illustrate the Pulsar community's firm commitment to education and ecosystem development. More importantly, they demonstrate the momentum and growth we can expect in the future.</p>
<h2><a class="anchor" aria-hidden="true" id="special-thanks"></a><a href="#special-thanks" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Special Thanks</h2>
<p>We would like to thank the Pulsar community, contributors and committers, who have helped to drive development, growth and adoption for Pulsar. We would especially like to recognize our distinguished contributors and committers (including but not limited to):</p>
<ul>
<li><a href="https://github.com/merlimat">Matteo Merli</a> from <a href="https://www.splunk.com/">Splunk</a></li>
<li><a href="https://github.com/rdhabalia">Rajan Dhabalia</a> from <a href="https://www.verizonmedia.com/">Verizon Media</a></li>
<li><a href="https://github.com/sijie">Sijie Guo</a> from <a href="https://streamnative.io/">StreamNative</a></li>
<li><a href="https://github.com/srkukarni">Sanjeev Kulkarni</a> from <a href="https://www.splunk.com/">Splunk</a></li>
<li><a href="https://github.com/jerrypeng">Boyang Jerry Peng</a> from <a href="https://www.splunk.com/">Splunk</a></li>
<li><a href="https://github.com/ivankelly">Ivan Brendan Kelly</a> from <a href="https://www.splunk.com/">Splunk</a></li>
<li><a href="https://github.com/codelipenghui">Penghui Li</a> from <a href="http://www.zhaopin.com/">Zhaopin.com</a></li>
<li><a href="https://github.com/jiazhai">Jia Zhai</a> from <a href="https://streamnative.io/">StreamNative</a></li>
</ul>
<p>To view other contributors, see <a href="https://github.com/apache/pulsar/graphs/contributors">Pulsar contributor list</a>.</p>
<h2><a class="anchor" aria-hidden="true" id="get-involved"></a><a href="#get-involved" aria-hidden="true" class="hash-link"><svg class="hash-link-icon" aria-hidden="true" height="16" version="1.1" viewBox="0 0 16 16" width="16"><path fill-rule="evenodd" d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"></path></svg></a>Get Involved</h2>
<p>We invite you to join this fast-growing community. Together, we will continue to develop technology to meet today’s most innovative messaging and event-streaming use cases and to help companies unlock the value of real-time data.</p>
<p>Whether it is joining our <a href="https://apache-pulsar.slack.com/">Pulsar Slack channel</a>, sharing your Pulsar story via a sponsored <a href="https://www.youtube.com/watch?v=mncXc_T6JkU&amp;list=PLqRma1oIkcWhfmUuJrMM5YIG8hjju62Ev">webinar</a> or case study, joining a <a href="https://github.com/streamnative/tgip">TGIP</a>/<a href="https://github.com/streamnative/tgip-cn">TGIP-CN</a>, or attending or speaking at the next Pulsar Summit, we look forward to connecting with you.</p>
<p>You can also subscribe our mailing lists: <a href="mailto:users-subscribe@pulsar.apache.org">users@pulsar.apache.org</a> and <a href="mailto:dev-subscribe@pulsar.apache.org">dev@pulsar.apache.org</a>.</p>
</span></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/08/21/Apache-Pulsar-2-6-1">Apache Pulsar 2.6.1</a></h1><p class="post-meta">August 21, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/wolf4j1" target="_blank" rel="noreferrer noopener">XiaoLong Ran</a></p></div></header><article class="post-content"><div><span><p>We are excited to see that the Apache Pulsar community has successfully released 2.6.1 version after a lot of hard work. It is a great milestone for this fast-growing project and the Pulsar community. 2.6.1 is the result of a big effort from the community, with over 100 commits and a long list of improvements and bug fixes.</p>
<p>Here are some highlights and major features added in Pulsar 2.6.1.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/08/21/Apache-Pulsar-2-6-1">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/06/18/Apache-Pulsar-2-6-0">Apache Pulsar 2.6.0</a></h1><p class="post-meta">June 18, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/lipenghui6" target="_blank" rel="noreferrer noopener">Penghui Li</a></p></div></header><article class="post-content"><div><span><p>We are very glad to see the Apache Pulsar community has successfully released the wonderful 2.6.0 version after accumulated hard work. It is a great milestone for this fast-growing project and the whole Pulsar community. This is the result of a huge effort from the community, with over 450 commits and a long list of new features, improvements, and bug fixes.</p>
<p>Here is a selection of some of the most interesting and major features added to Pulsar 2.6.0.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/06/18/Apache-Pulsar-2-6-0">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/05/19/Apache-Pulsar-2-5-2">Apache Pulsar 2.5.2</a></h1><p class="post-meta">May 19, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/Jia_Zhai" target="_blank" rel="noreferrer noopener">Jia Zhai</a></p></div></header><article class="post-content"><div><span><p>We are proud to publish Apache Pulsar 2.5.2. This is the result of a huge effort from the community, with over 56 commits, general improvements and bug fixes.</p>
<p>For detailed changes related to 2.5.2 release, refer to the <b><a href="/release-notes/#2.5.2">release notes</a></b> and the <b><a href="https://github.com/apache/pulsar/pulls?q=is:pr%20label:release/2.5.2%20is:closed">PR list for Pulsar 2.5.2</a></b>.</p>
<p>The following highlights some improved features and fixed bugs in this release.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/05/19/Apache-Pulsar-2-5-2">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/04/23/Apache-Pulsar-2-5-1">Apache Pulsar 2.5.1</a></h1><p class="post-meta">April 23, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/tuteng3" target="_blank" rel="noreferrer noopener">Guangning E</a></p></div></header><article class="post-content"><div><span><p>We are proud to publish Apache Pulsar 2.5.1. This is the result of a huge effort from the community, with over 130 commits and a long list of new features, general improvements and bug fixes.</p>
<p>For detailed changes related to 2.5.1 release, refer to the <b><a href="/release-notes/#2.5.1">release notes</a></b> and the <b><a href="https://github.com/apache/pulsar/pulls?q=is:pr%20label:release/2.5.1%20is:closed">PR list for Pulsar 2.5.1</a></b>.</p>
<p>The following justs highlights a tiny subset of new features.</p>
</span></div><div class="read-more"><a class="button" href="/blog/2020/04/23/Apache-Pulsar-2-5-1">Read More</a></div></article></div><div class="post"><header class="postHeader"><h1 class="postHeaderTitle"><a href="/blog/2020/03/17/announcing-the-apache-pulsar-2020-user-survey-report">Announcing: The Apache Pulsar 2020 User Survey Report</a></h1><p class="post-meta">March 17, 2020</p><div class="authorBlock"><p class="post-authorName"><a href="https://twitter.com/sijieg" target="_blank" rel="noreferrer noopener">Sijie Guo</a></p></div></header><article class="post-content"><div><span><p>For the first time ever, the Apache Pulsar PMC team is publishing a user survey report.
<strong>The 2020 Apache Pulsar User Survey Report</strong> reveals Pulsar’s accelerating rate of global
adoption, details how organizations are leveraging Pulsar to build real-time streaming
applications, and highlights key features on Pulsar’s product roadmap.</p>
<p><img src="../img/pulsar-user-ban.jpg" alt=""></p>
<p>Pulsar adoption has largely been driven by the market’s increased demand for real-time,
data-enabled technologies. While companies have tried to leverage monolithic messaging
systems to build-out real-time offerings, they’ve hit major roadblocks. Ultimately, these
technologies are not equipped to provide the scale or reliability that mission-critical
applications require.</p>
<p>As a result, companies have sought-out Apache Pulsar for its cloud-native, distributed
messaging and streaming platform capabilities. From asynchronous applications to core
business applications to ETL, companies are increasingly leveraging Pulsar to develop
real-time applications.</p>
<p>Pulsar has received global adoption from major technology companies such as Verizon Media,
Narvar, Overstock, Nutanix, Yahoo! JAPAN, Tencent, OVHCloud, and Clever Cloud, who rely on
its ability to deliver on performance, scalability, and resiliency. As the Pulsar project
and community garner increasing attention, we’re excited to share the <strong>2020 Apache Pulsar User Survey Report</strong>.</p>
<p><img src="../img/pulsar-adoption.png" alt=""></p>
<p>In the 2020 Apache Pulsar User Survey Report, we hear from 165 users and learn how their
companies are leveraging Pulsar’s cloud-native, multi-layer design architecture, built-in
multi-tenancy, and multi-cluster replication, to build scalable real-time offerings. This
report details insights and use cases on how organizations are deploying Pulsar today.</p>
<p>The report also reveals Pulsar’s top-used features, its most popular applications, and how
it is delivering scalable, reliable, real-time streaming solutions for organizations. In
this quotation from Qiang Fei, Tech Lead for Tencent, we see how
<a href="https://streamnative.io/whitepaper/case-studay-apache-pulsar-tencent-billing/">one organization is leveraging Pulsar to improve their offering</a>:</p>
<blockquote>
<p>Pulsar provides us with a highly consistent and highly reliable distributed message queue that
fits well in our financial use cases. Multi-tenant and storage separation architecture design
greatly reduces our operational and maintenance overhead. We have used Pulsar on a very large
scale in our organization and we are impressed that Pulsar is able to provide high consistency
while supporting high concurrent client connections.</p>
<ul>
<li>Qiang Fei, Tech Lead at Tencent</li>
</ul>
</blockquote>
<p>From its built-in multi-tenancy, which reduces architectural complexity and enables organizations
to scale, to its multi-datacenter replication, which allows Pulsar to handle data center failures,
we see how Pulsar has evolved into a robust and differentiated messaging and streaming platform.
The report also reveals some of the community-driven features on Pulsar’s product roadmap for 2020
and beyond. To find out more, <a href="https://streamnative.io/whitepaper/oss-apache-pulsar-user-survey-report-2020/">download the report today</a>.</p>
<p>Join us for the first-ever Apache Pulsar Summit on August 26, 2020, in San Francisco, CA.
More details on the Summit to come!</p>
</span></div></article></div><div class="docs-prevnext"><a class="docs-prev" href="/blog/">← Prev</a><a class="docs-next" href="/blog/page3/">Next →</a></div></div></div></div></div><footer class="nav-footer" id="footer"><section class="copyright">Copyright © 2022 The Apache Software Foundation. All Rights Reserved. Apache, Apache Pulsar and the Apache feather logo are trademarks of The Apache Software Foundation.</section><span><script>
      const community = document.querySelector("a[href='#community']").parentNode;
      const communityMenu =
        '<li>' +
        '<a id="community-menu" href="#">Community <span style="font-size: 0.75em">&nbsp;▼</span></a>' +
        '<div id="community-dropdown" class="hide">' +
          '<ul id="community-dropdown-items">' +
            '<li><a href="/en/contact">Contact</a></li>' +
            '<li><a href="/en/contributing">Contributing</a></li>' +
            '<li><a href="/en/coding-guide">Coding guide</a></li>' +
            '<li><a href="/en/events">Events</a></li>' +
            '<li><a href="https://twitter.com/Apache_Pulsar" target="_blank">Twitter &#x2750</a></li>' +
            '<li><a href="https://github.com/apache/pulsar/wiki" target="_blank">Wiki &#x2750</a></li>' +
            '<li><a href="https://github.com/apache/pulsar/issues" target="_blank">Issue tracking &#x2750</a></li>' +
            '<li><a href="https://pulsar-summit.org/" target="_blank">Pulsar Summit &#x2750</a></li>' +
            '<li>&nbsp;</li>' +
            '<li><a href="/en/resources">Resources</a></li>' +
            '<li><a href="/en/team">Team</a></li>' +
            '<li><a href="/en/powered-by">Powered By</a></li>' +
          '</ul>' +
        '</div>' +
        '</li>';

      community.innerHTML = communityMenu;

      const communityMenuItem = document.getElementById("community-menu");
      const communityDropDown = document.getElementById("community-dropdown");
      communityMenuItem.addEventListener("click", function(event) {
        event.preventDefault();

        if (communityDropDown.className == 'hide') {
          communityDropDown.className = 'visible';
        } else {
          communityDropDown.className = 'hide';
        }
      });
    </script></span></footer></div><script>window.twttr=(function(d,s, id){var js,fjs=d.getElementsByTagName(s)[0],t=window.twttr||{};if(d.getElementById(id))return t;js=d.createElement(s);js.id=id;js.src='https://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js, fjs);t._e = [];t.ready = function(f) {t._e.push(f);};return t;}(document, 'script', 'twitter-wjs'));</script></body></html>