<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-post-page plugin-blog plugin-id-default">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.0">
<title data-rh="true">What&#x27;s New in Apache Pulsar 3.2.0 | Apache Pulsar</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:image" content="https://pulsar.apache.org/img/pulsar-social-media-card.png"><meta data-rh="true" name="twitter:image" content="https://pulsar.apache.org/img/pulsar-social-media-card.png"><meta data-rh="true" property="og:url" content="https://pulsar.apache.org/blog/2024/02/12/announcing-apache-pulsar-3-2/"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="What&#x27;s New in Apache Pulsar 3.2.0 | Apache Pulsar"><meta data-rh="true" name="description" content="The Apache Pulsar community is thrilled to announce the launch of Apache Pulsar 3.2, a new feature release! This achievement is the result of a significant community collaboration, involving 57 contributors who made over 88 commits to add new features and fix bugs. Our heartfelt thanks go out to every contributor for their invaluable work!"><meta data-rh="true" property="og:description" content="The Apache Pulsar community is thrilled to announce the launch of Apache Pulsar 3.2, a new feature release! This achievement is the result of a significant community collaboration, involving 57 contributors who made over 88 commits to add new features and fix bugs. Our heartfelt thanks go out to every contributor for their invaluable work!"><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2024-02-12T00:00:00.000Z"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://pulsar.apache.org/blog/2024/02/12/announcing-apache-pulsar-3-2/"><link data-rh="true" rel="alternate" href="https://pulsar.apache.org/blog/2024/02/12/announcing-apache-pulsar-3-2/" hreflang="en"><link data-rh="true" rel="alternate" href="https://pulsar.apache.org/blog/2024/02/12/announcing-apache-pulsar-3-2/" hreflang="x-default"><link data-rh="true" rel="preconnect" href="https://WK2YL0SALL-dsn.algolia.net" crossorigin="anonymous"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache Pulsar RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache Pulsar Atom Feed">



<link rel="search" type="application/opensearchdescription+xml" title="Apache Pulsar" href="/opensearch.xml">





<link rel="stylesheet" href="/css/katex-0.13.24.min.css" media="print" onload="this.media=&#39;all&#39;">
<script src="/js/sine-waves.min.js" async></script>
<script src="/js/matomo-agent.js"></script><link rel="stylesheet" href="/assets/css/styles.dd05f1d2.css">
<link rel="preload" href="/assets/js/runtime~main.085f4a9c.js" as="script">
<link rel="preload" href="/assets/js/main.3cd5fa20.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}(),document.documentElement.setAttribute("data-announcement-bar-initially-dismissed",function(){try{return"true"===localStorage.getItem("docusaurus.announcement.dismiss")}catch(t){}return!1}())</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#docusaurus_skipToContent_fallback">Skip to main content</a></div><div class="announcementBar_mb4j" style="background-color:#282826;color:#fff" role="banner"><div class="content_knG7 announcementBarContent_xLdY">
    <a class="announcement-bar" href="/community/#section-discussions" target="_blank">
      <div class="announcement-bar__content">
        <!-- <svg class="announcement-bar__icon">
          
<svg viewBox="0 0 33 32" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M6.5 19.6001H16.1L15.3 29.2001L26.5 12.4H17.06L18.1 2.80005L6.5 19.6001Z" stroke="#F7F7F7" stroke-width="1.5" stroke-linejoin="round"/>
</svg>

        </svg> -->

        <span>
          👋 Start your Pulsar journey by becoming a member of our community
        </span>

        <svg class="announcement-bar__icon">
          
<svg viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
<rect width="20" height="20" transform="translate(6 6)" fill="white" fill-opacity="0.01"/>
<path d="M17.6667 10.1667L23.5 16.0001M23.5 16.0001L17.6667 21.8334M23.5 16.0001L8.5 16.0001" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
<rect x="0.5" y="0.5" width="31" height="31" rx="15.5" stroke="white"/>
</svg>

        </svg>
      </div>
    </a>
  </div></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/logo-black.svg" alt="Apache Pulsar logo" class="themedImage_ToTc themedImage--light_HNdA" height="25" width="127"><img src="/img/logo-black.svg" alt="Apache Pulsar logo" class="themedImage_ToTc themedImage--dark_i4oU" height="25" width="127"></div><b class="navbar__title text--truncate"></b></a><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Get Started</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/docs/3.2.x/concepts-overview/">Concepts</a></li><li><a class="dropdown__link" href="/docs/3.2.x/">Quickstart</a></li><li><a class="dropdown__link" href="/ecosystem/">Ecosystem</a></li></ul></div><a class="navbar__item navbar__link" href="/docs/3.2.x/">Docs</a><a class="navbar__item navbar__link" href="/features/">Features</a><a class="navbar__item navbar__link" href="/use-cases/">Use Cases</a><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link community-dropdown">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link scroll-link scroll-welcome" id="scroll-welcome" href="/community/">Welcome</a></li><li><a class="dropdown__link scroll-link scroll-discussions" id="scroll-discussions" href="/community/#section-discussions">Discussions</a></li><li><a class="dropdown__link scroll-link" id="scroll-governance" href="/community/#section-governance">Governance</a></li><li><a class="dropdown__link scroll-link" id="scroll-community" href="/community/#section-community">Meet the Community</a></li><li><a class="dropdown__link scroll-link" id="scroll-contribute" href="/community/#section-contribute">Contribute</a></li><li><a class="dropdown__link" href="/contribute/">Contribution Guide</a></li><li><a href="https://github.com/apache/pulsar/wiki" target="_blank" rel="noopener noreferrer" class="dropdown__link">Wiki</a></li><li><a href="https://github.com/apache/pulsar/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issue Tracking</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Learn</a><ul class="dropdown__menu"><li><a aria-current="page" class="dropdown__link dropdown__link--active" href="/blog/">Blog</a></li><li><a class="dropdown__link" href="/books/">Books</a></li><li><a class="dropdown__link" href="/case-studies/">Case Studies</a></li><li><a class="dropdown__link" href="/articles/">Articles</a></li><li><a class="dropdown__link" href="/presentations/">Presentations</a></li><li><a class="dropdown__link" href="/events/">Events</a></li></ul></div></div><div class="navbar__items navbar__items--right"><a class="navbar__item navbar__link navbar_download_button" href="/download/">Download</a><div class="searchBox_ZlJk"><button type="button" class="DocSearch DocSearch-Button" aria-label="Search"><span class="DocSearch-Button-Container"><svg width="20" height="20" class="DocSearch-Search-Icon" viewBox="0 0 20 20" aria-hidden="true"><path d="M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z" stroke="currentColor" fill="none" fill-rule="evenodd" stroke-linecap="round" stroke-linejoin="round"></path></svg><span class="DocSearch-Button-Placeholder">Search</span></span><span class="DocSearch-Button-Keys"></span></button></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><div class="container margin-top--lg"><div class="row"><main class="col col--12" itemscope="" itemtype="https://schema.org/Blog"><article class="BlogContainerPost_N_n1" itemprop="blogPost" itemscope="" itemtype="https://schema.org/BlogPosting"><header><div><h1 class="title_xvU1" itemprop="headline">What&#x27;s New in Apache Pulsar 3.2.0</h1><div class="row"><div class="col authorCol_q4o9"><div class="avatar"><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><span itemprop="name">Julien Jakubowski</span></div></div></div></div></div><div class="container_iJTo"><time datetime="2024-02-12T00:00:00.000Z" itemprop="datePublished">February 12, 2024</time> · <!-- -->4 min read</div></div></header><div id="post-content" class="markdown" itemprop="articleBody"><p>The Apache Pulsar community is thrilled to announce the launch of Apache Pulsar 3.2, a new feature release! This achievement is the result of a significant community collaboration, involving 57 contributors who made over 88 commits to add new features and fix bugs. Our heartfelt thanks go out to every contributor for their invaluable work!</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="whats-new-in-apache-pulsar-32">What&#x27;s new in Apache Pulsar 3.2?<a href="#whats-new-in-apache-pulsar-32" class="hash-link" aria-label="Direct link to What&#x27;s new in Apache Pulsar 3.2?" title="Direct link to What&#x27;s new in Apache Pulsar 3.2?">​</a></h2><p>This release introduces <a href="https://pulsar.apache.org/release-notes/versioned/pulsar-3.2.0/" target="_blank" rel="noopener noreferrer">180+ improvements, optimizations, and fixes</a> on the broker, Pulsar IO/Pulsar Functions, CLI, and others.</p><p>It also unveils key new features, highlighted below.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="rate-limiting">Rate limiting<a href="#rate-limiting" class="hash-link" aria-label="Direct link to Rate limiting" title="Direct link to Rate limiting">​</a></h3><p>An increasing number of messaging-as-a-service platform teams are adopting Apache Pulsar as their main building block for providing messaging services across their organizations. This is clear validation that the value of Apache Pulsar’s truly multi-tenant architecture is delivering results, making Apache Pulsar a cost-efficient and reliable solution for messaging-as-a-service platform teams in very demanding application environments.</p><p>In the Apache Pulsar project, we are committed to delivering further improvements to the existing multi-tenancy features. One area of improvement is the service level management and capacity management of a large Pulsar system. This is also a key concern of messaging-as-a-service platform teams.</p><p>Apache Pulsar 3.2.0 features the implementation of <a href="https://github.com/apache/pulsar/blob/master/pip/pip-322.md" target="_blank" rel="noopener noreferrer">PIP-322 Pulsar Rate Limiting Refactoring</a>. Rate limiters act as a conduit to more extensive capacity management and Quality of Service (QoS) controls in Pulsar. They are integral to Pulsar&#x27;s core multi-tenancy features. This refactoring paves the way for future enhancements in this area.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="null-key-messages-deletion-during-compaction">Null-key messages deletion during compaction<a href="#null-key-messages-deletion-during-compaction" class="hash-link" aria-label="Direct link to Null-key messages deletion during compaction" title="Direct link to Null-key messages deletion during compaction">​</a></h3><p>Apache Pulsar supports <a href="https://pulsar.apache.org/docs/3.2.x/concepts-topic-compaction/" target="_blank" rel="noopener noreferrer">Topic Compaction</a>.</p><p>In versions 3.1.0 and earlier of Pulsar, topic compaction retains messages that have null keys.</p><p>Starting with Pulsar 3.2.0, the default behavior has been changed to delete messages with null keys during topic compaction, which helps in reducing storage costs. However, if necessary, you can revert to the previous behavior by setting <code>topicCompactionRetainNullKey=true</code> in <code>broker.conf</code>.</p><p>For more details, refer to the description in <a href="https://github.com/apache/pulsar/blob/master/pip/pip-318.md" target="_blank" rel="noopener noreferrer">PIP-318</a>.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="websockets-new-features">WebSockets new features<a href="#websockets-new-features" class="hash-link" aria-label="Direct link to WebSockets new features" title="Direct link to WebSockets new features">​</a></h3><p>The Pulsar WebSocket API now supports:</p><ul><li>Consuming multiple topics as described in <a href="https://github.com/apache/pulsar/blob/master/pip/pip_307.md" target="_blank" rel="noopener noreferrer">PIP-307</a>.</li><li>End-to-end encryption, as described in <a href="https://github.com/apache/pulsar/blob/master/pip/pip-290.md" target="_blank" rel="noopener noreferrer">PIP-290</a>.</li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="enhanced-security-for-pulsar-functions--pulsar-io">Enhanced security for Pulsar Functions &amp; Pulsar IO<a href="#enhanced-security-for-pulsar-functions--pulsar-io" class="hash-link" aria-label="Direct link to Enhanced security for Pulsar Functions &amp; Pulsar IO" title="Direct link to Enhanced security for Pulsar Functions &amp; Pulsar IO">​</a></h3><p>Pulsar 3.2.0 provides increased security for Pulsar Functions &amp; Pulsar IO by allowing users to configure Pulsar Connectors with non-plaintext secrets. More details in <a href="https://github.com/apache/pulsar/blob/master/pip/pip-289.md" target="_blank" rel="noopener noreferrer">PIP-289</a> &amp; the following pull requests:</p><ul><li><a href="https://github.com/apache/pulsar/pull/21675" target="_blank" rel="noopener noreferrer">Make connectors load sensitive fields from secrets</a></li><li><a href="https://github.com/apache/pulsar/pull/20901" target="_blank" rel="noopener noreferrer">Support configuration secret interpolation</a></li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cli-user-experience-improvements">CLI user experience improvements<a href="#cli-user-experience-improvements" class="hash-link" aria-label="Direct link to CLI user experience improvements" title="Direct link to CLI user experience improvements">​</a></h3><p>This release introduces several handy features to the CLI, including:</p><ul><li><a href="https://github.com/apache/pulsar/pull/20663" target="_blank" rel="noopener noreferrer">Add command line option for configuring the memory limit</a></li><li><a href="https://github.com/apache/pulsar/pull/21664" target="_blank" rel="noopener noreferrer">Allow for deleting topics in bulk, using a regex or a file</a></li><li><a href="https://github.com/apache/pulsar/pull/20614" target="_blank" rel="noopener noreferrer">Display the current cluster in <code>pulsar-admin clusters list</code></a></li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="build-improvement">Build improvement<a href="#build-improvement" class="hash-link" aria-label="Direct link to Build improvement" title="Direct link to Build improvement">​</a></h3><p>Pulsar 3.2.0 also introduces enhancements to the build process and reliability, including a Bill of Materials (BOM) to simplify dependency management, as outlined in <a href="https://github.com/apache/pulsar/blob/master/pip/pip-326.md" target="_blank" rel="noopener noreferrer">PIP-326</a>. </p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="more">More<a href="#more" class="hash-link" aria-label="Direct link to More" title="Direct link to More">​</a></h3><p>Feel free to explore the <a href="https://github.com/apache/pulsar/releases/tag/v3.2.0" target="_blank" rel="noopener noreferrer">full release notes</a> for a detailed list of all improvements and fixes.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="compatibility-between-releases">Compatibility between releases<a href="#compatibility-between-releases" class="hash-link" aria-label="Direct link to Compatibility between releases" title="Direct link to Compatibility between releases">​</a></h2><p>When upgrading an existing Pulsar installation, it&#x27;s crucial to perform component upgrades in a sequential manner.</p><p>Starting from version 3.0, users have the option to perform live upgrades or downgrades between two consecutive LTS versions or two consecutive feature versions (which also include LTS versions).</p><p>For the 3.2 series, you should be able to upgrade from version 3.x. </p><p>Please refer to the <a href="/contribute/release-policy/">release policy</a> to learn more about the compatibility between releases.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="getting-started">Getting started<a href="#getting-started" class="hash-link" aria-label="Direct link to Getting started" title="Direct link to Getting started">​</a></h2><p>Pulsar 3.2.0 is now available for <a href="https://pulsar.apache.org/download/" target="_blank" rel="noopener noreferrer">download</a>. To get started with Pulsar, you can run a Pulsar cluster <a href="https://pulsar.apache.org/docs/3.2.x/getting-started-home/" target="_blank" rel="noopener noreferrer">on your local machine, Docker, or Kubernetes</a>.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="getting-involved">Getting involved<a href="#getting-involved" class="hash-link" aria-label="Direct link to Getting involved" title="Direct link to Getting involved">​</a></h2><p>Apache Pulsar is one of the fastest-growing open-source projects, recognized by the <a href="https://thestack.technology/top-apache-projects-in-2021-from-superset-to-nuttx/" target="_blank" rel="noopener noreferrer">Apache Software Foundation</a> as a Top 5 Project based on engagement. The vitality of Pulsar relies on continued community growth, which would not be possible without each and every contributor to the project. The Pulsar community welcomes contributions from anyone with a passion for open source, messaging, and streaming, as well as distributed systems! Looking for more ways to stay connected with the Pulsar community? Check out the following resources:</p><ul><li>Pulsar Summit North America 2023 took place on Wednesday, October 25, 2023! <a href="https://pulsar-summit.org/event/north-america-2023/schedule" target="_blank" rel="noopener noreferrer">Watch the sessions recordings</a>. Follow <a href="https://twitter.com/pulsarsummit" target="_blank" rel="noopener noreferrer">@PulsarSummit</a> on Twitter/X for updates and details on the upcoming Pulsar Summit events.</li><li>Read the <a href="https://pulsar.apache.org/contribute/" target="_blank" rel="noopener noreferrer">Apache Pulsar Contribution Guide</a> to start your first contribution.</li><li>Visit the <a href="https://github.com/apache/pulsar" target="_blank" rel="noopener noreferrer">Pulsar GitHub repository</a>, follow <a href="https://twitter.com/apache_pulsar" target="_blank" rel="noopener noreferrer">@apache_pulsar</a> on Twitter/X , and join the <a href="https://apache-pulsar.slack.com/" target="_blank" rel="noopener noreferrer">Pulsar community on Slack</a>.</li></ul></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_Wr5y"><div class="col margin-top--sm"><a href="https://github.com/apache/pulsar-site/edit/main/blog/2024-02-12-announcing-apache-pulsar-3-2.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div></footer></article><nav class="pagination-nav blog-post-pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><div><a class="pagination-nav__link pagination-nav__link--next" href="/blog/2024/01/12/pulsar-2023-year-in-review/"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache Pulsar 2023 Year in Review</div></a><div class="blog-post-pagination-nav-more"><a href="/blog">Show All</a></div></div></nav></main></div></div></div><footer class="footer"><div class="container container-fluid"><div class="row footer__links"><div class="col footer__col"><div class="footer__title"></div><ul class="footer__items clean-list"><li class="footer__item"><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="footer__link-item">Foundation<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/events/current-event.html" target="_blank" rel="noopener noreferrer" class="footer__link-item">Events<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="col footer__col"><div class="footer__title"></div><ul class="footer__items clean-list"><li class="footer__item"><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="footer__link-item">License<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/foundation/thanks" target="_blank" rel="noopener noreferrer" class="footer__link-item">Thanks<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/foundation/sponsorship" target="_blank" rel="noopener noreferrer" class="footer__link-item">Sponsorship<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="col footer__col"><div class="footer__title"></div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/security/">Security</a></li><li class="footer__item"><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="footer__link-item">Privacy<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a class="footer__link-item" href="/contact/">Contact</a></li></ul></div><div class="col footer__col"><div class="footer__title"></div><ul class="footer__items clean-list"><li class="footer__item">
                <div class="social-icons">
                  <a target="_blank" href="https://communityinviter.com/apps/apache-pulsar/apache-pulsar" aria-label="Join the Apache Pulsar Slack workspace">
                    <img alt="Slack logo" src="/img/slack-white.svg" width="26">
                  </a>
                  <a target="_blank" href="https://github.com/apache/pulsar/" aria-label="View the Apache Pulsar project on GitHub">
                    <img alt="GitHub logo" src="/img/github-white.svg" width="26">
                  </a>
                </div>
              </li></ul></div></div><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a class="footerLogoLink_BH7S" href="/"><img src="/img/pulsar-white.svg" alt="Pulsar Logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/pulsar-white.svg" alt="Pulsar Logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
        <div>
          <img class="footer-apache-logo" src="/img/feather-logo-white.svg" alt="" width="20">
          The Apache Software Foundation
        </div>
        <p>Apache Pulsar is available under the Apache License, version 2.0. Apache Pulsar is an open-source, distributed messaging and streaming platform built for the cloud.</p>
        <p>Copyright © 2024 The Apache Software Foundation. All Rights Reserved. Apache, Pulsar, Apache Pulsar, and the Apache feather logo are trademarks or registered trademarks of The Apache Software Foundation.</p>
      </div></div></div></footer></div>
<script src="/assets/js/runtime~main.085f4a9c.js"></script>
<script src="/assets/js/main.3cd5fa20.js"></script>
</body>
</html>