<!doctype html>
<html lang="en" dir="ltr" class="docs-wrapper docs-doc-page docs-version-4.8.2 plugin-docs plugin-id-default docs-doc-id-admin/upgrade">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.0">
<title data-rh="true">Upgrade | Apache BookKeeper</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:url" content="https://bookkeeper.apache.org/docs/4.8.2/admin/upgrade"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docusaurus_version" content="4.8.2"><meta data-rh="true" name="docusaurus_tag" content="docs-default-4.8.2"><meta data-rh="true" name="docsearch:version" content="4.8.2"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-4.8.2"><meta data-rh="true" property="og:title" content="Upgrade | Apache BookKeeper"><meta data-rh="true" name="description" content="If you have questions about upgrades (or need help), please feel free to reach out to us by mailing list or Slack Channel."><meta data-rh="true" property="og:description" content="If you have questions about upgrades (or need help), please feel free to reach out to us by mailing list or Slack Channel."><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://bookkeeper.apache.org/docs/4.8.2/admin/upgrade"><link data-rh="true" rel="alternate" href="https://bookkeeper.apache.org/docs/4.8.2/admin/upgrade" hreflang="en"><link data-rh="true" rel="alternate" href="https://bookkeeper.apache.org/docs/4.8.2/admin/upgrade" hreflang="x-default"><link rel="stylesheet" href="/assets/css/styles.49914aab.css">
<link rel="preload" href="/assets/js/runtime~main.793d926f.js" as="script">
<link rel="preload" href="/assets/js/main.c5d52852.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")}()</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><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/bk-logo.svg" alt="Apache Bookkeeper" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/bk-logo.svg" alt="Apache Bookkeeper" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate">Apache BookKeeper</b></a><a aria-current="page" class="navbar__item navbar__link navbar__link--active" href="/docs/4.8.2/overview/">Documentation</a><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/community/mailing-lists">Mailing lists</a></li><li><a class="dropdown__link" href="/community/slack">Slack</a></li><li><a href="https://github.com/apache/bookkeeper/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Github issues<svg width="12" height="12" 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><a class="dropdown__link" href="/community/releases">Release management</a></li><li><a class="dropdown__link" href="/community/meeting">Community meetings</a></li><li><a class="dropdown__link" href="/community/contributing">Contribution guide</a></li><li><a class="dropdown__link" href="/community/coding-guide">Coding guide</a></li><li><a class="dropdown__link" href="/community/testing">Testing guide</a></li><li><a class="dropdown__link" href="/community/issue-report">Issue report guide</a></li><li><a class="dropdown__link" href="/community/release-guide">Release guide</a></li><li><a class="dropdown__link" href="/community/presentations">Presentations</a></li><li><a class="dropdown__link" href="/community/bookkeeper-proposals">BookKeeper proposals (BP)</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Project</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/project/who">Who are we?</a></li><li><a class="dropdown__link" href="/project/bylaws">Bylaws</a></li><li><a href="https://apache.org/licenses" target="_blank" rel="noopener noreferrer" class="dropdown__link">License<svg width="12" height="12" 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><a class="dropdown__link" href="/project/privacy">Privacy policy</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship<svg width="12" height="12" 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><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks<svg width="12" height="12" 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><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a class="navbar__link" aria-haspopup="true" aria-expanded="false" role="button" href="/docs/4.8.2/overview/">4.8.2</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/docs/next/admin/upgrade">Next</a></li><li><a class="dropdown__link" href="/docs/admin/upgrade">4.16.5</a></li><li><a class="dropdown__link" href="/docs/4.15.5/admin/upgrade">4.15.5</a></li><li><a class="dropdown__link" href="/docs/4.14.8/admin/upgrade">4.14.8</a></li><li><a class="dropdown__link" href="/docs/4.13.0/admin/upgrade">4.13.0</a></li><li><a class="dropdown__link" href="/docs/4.12.1/admin/upgrade">4.12.1</a></li><li><a class="dropdown__link" href="/docs/4.11.1/admin/upgrade">4.11.1</a></li><li><a class="dropdown__link" href="/docs/4.10.0/admin/upgrade">4.10.0</a></li><li><a class="dropdown__link" href="/docs/4.9.2/admin/upgrade">4.9.2</a></li><li><a aria-current="page" class="dropdown__link dropdown__link--active" href="/docs/4.8.2/admin/upgrade">4.8.2</a></li><li><a class="dropdown__link" href="/docs/4.7.3/admin/upgrade">4.7.3</a></li><li><a class="dropdown__link" href="/docs/4.6.2/admin/upgrade">4.6.2</a></li><li><a class="dropdown__link" href="/docs/4.5.1/admin/upgrade">4.5.1</a></li></ul></div><a class="navbar__item navbar__link" href="/releases">Download</a><div class="toggle_vylO colorModeToggle_DEke"><button class="clean-btn toggleButton_gllP toggleButtonDisabled_aARS" type="button" disabled="" title="Switch between dark and light mode (currently light mode)" aria-label="Switch between dark and light mode (currently light mode)" aria-live="polite"><svg viewBox="0 0 24 24" width="24" height="24" class="lightToggleIcon_pyhR"><path fill="currentColor" d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"></path></svg><svg viewBox="0 0 24 24" width="24" height="24" class="darkToggleIcon_wfgR"><path fill="currentColor" d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"></path></svg></button></div><div class="searchBox_ZlJk"></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0 docsWrapper_BCFX"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type="button"></button><div class="docPage__5DB"><aside class="theme-doc-sidebar-container docSidebarContainer_b6E3"><div class="sidebarViewport_Xe31"><div class="sidebar_njMd"><nav aria-label="Docs sidebar" class="menu thin-scrollbar menu_SIkG"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/4.8.2/overview/">Overview</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/getting-started/installation">Getting started</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/deployment/manual">Deployment</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret menu__link--active" aria-expanded="true" href="/docs/4.8.2/admin/bookies">Administration</a></div><ul style="display:block;overflow:visible;height:auto" class="menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/4.8.2/admin/bookies">BookKeeper administration</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/4.8.2/admin/autorecovery">AutoRecovery</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/4.8.2/admin/metrics">Metrics collection</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/4.8.2/admin/upgrade">Upgrade</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/4.8.2/admin/http">Admin REST API</a></li></ul></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/api/overview">API</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/security/overview">Security</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/development/protocol">Development</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/4.8.2/reference/config">Reference</a></div></li></ul></nav></div></div></aside><main class="docMainContainer_gTbr"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_VOVn"><div class="docItemContainer_Djhp"><article><span class="theme-doc-version-badge badge badge--secondary">Version: 4.8.2</span><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type="button" class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>Upgrade</h1></header><blockquote><p>If you have questions about upgrades (or need help), please feel free to reach out to us by <!-- -->[mailing list]<!-- -->({{ community/mailing-lists) or <!-- -->[Slack Channel]<!-- -->({{ community/slack).</p></blockquote><h2 class="anchor anchorWithStickyNavbar_LWe7" id="overview">Overview<a href="#overview" class="hash-link" aria-label="Direct link to Overview" title="Direct link to Overview">​</a></h2><p>Consider the below guidelines in preparation for upgrading.</p><ul><li>Always back up all your configuration files before upgrading.</li><li>Read through the documentation and draft an upgrade plan that matches your specific requirements and environment before starting the upgrade process.
Put differently, don&#x27;t start working through the guide on a live cluster. Read guide entirely, make a plan, then execute the plan.</li><li>Pay careful consideration to the order in which components are upgraded. In general, you need to upgrade bookies first and then upgrade your clients.</li><li>If autorecovery is running along with bookies, you need to pay attention to the upgrade sequence.</li><li>Read the release notes carefully for each release. They contain not only information about noteworthy features, but also changes to configurations
that may impact your upgrade.</li><li>Always upgrade one or a small set of bookies to canary new version before upgraing all bookies in your cluster.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="canary">Canary<a href="#canary" class="hash-link" aria-label="Direct link to Canary" title="Direct link to Canary">​</a></h2><p>It is wise to canary an upgraded version in one or small set of bookies before upgrading all bookies in your live cluster.</p><p>You can follow below steps on how to canary a upgraded version:</p><ol><li>Stop a Bookie.</li><li>Upgrade the binary and configuration.</li><li>Start the Bookie in <code>ReadOnly</code> mode. This can be used to verify if the Bookie of this new version can run well for read workload.</li><li>Once the Bookie is running at <code>ReadOnly</code> mode successfully for a while, restart the Bookie in <code>Write/Read</code> mode.</li><li>After step 4, the Bookie will serve both write and read traffic.</li></ol><h3 class="anchor anchorWithStickyNavbar_LWe7" id="rollback-canaries">Rollback Canaries<a href="#rollback-canaries" class="hash-link" aria-label="Direct link to Rollback Canaries" title="Direct link to Rollback Canaries">​</a></h3><p>If problems occur during canarying an upgraded version, you can simply take down the problematic Bookie node. The remain bookies in the old cluster
will repair this problematic bookie node by autorecovery. Nothing needs to be worried about.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="upgrade-steps">Upgrade Steps<a href="#upgrade-steps" class="hash-link" aria-label="Direct link to Upgrade Steps" title="Direct link to Upgrade Steps">​</a></h2><p>Once you determined a version is safe to upgrade in a few nodes in your cluster, you can perform following steps to upgrade all bookies in your cluster.</p><ol><li>Determine if autorecovery is running along with bookies. If yes, check if the clients (either new clients with new binary or old clients with new configurations)
are allowed to talk to old bookies; if clients are not allowed to talk to old bookies, please <a href="/docs/4.8.2/reference/cli/#autorecovery-1">disable autorecovery</a> during upgrade.</li><li>Decide on performing a rolling upgrade or a downtime upgrade.</li><li>Upgrade all Bookies (more below)</li><li>If autorecovery was disabled during upgrade, <a href="/docs/4.8.2/reference/cli/#autorecovery-1">enable autorecovery</a>.</li><li>After all bookies are upgraded, build applications that use <code>BookKeeper client</code> against the new bookkeeper libraries and deploy the new versions.</li></ol><h3 class="anchor anchorWithStickyNavbar_LWe7" id="upgrade-bookies">Upgrade Bookies<a href="#upgrade-bookies" class="hash-link" aria-label="Direct link to Upgrade Bookies" title="Direct link to Upgrade Bookies">​</a></h3><p>In a rolling upgrade scenario, upgrade one Bookie at a time. In a downtime upgrade scenario, take the entire cluster down, upgrade each Bookie, then start the cluster.</p><p>For each Bookie:</p><ol><li>Stop the bookie.</li><li>Upgrade the software (either new binary or new configuration)</li><li>Start the bookie.</li></ol><h2 class="anchor anchorWithStickyNavbar_LWe7" id="upgrade-guides">Upgrade Guides<a href="#upgrade-guides" class="hash-link" aria-label="Direct link to Upgrade Guides" title="Direct link to Upgrade Guides">​</a></h2><p>We describes the general upgrade method in Apache BookKeeper as above. We will cover the details for individual versions.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="46x-to-470-upgrade">4.6.x to 4.7.0 upgrade<a href="#46x-to-470-upgrade" class="hash-link" aria-label="Direct link to 4.6.x to 4.7.0 upgrade" title="Direct link to 4.6.x to 4.7.0 upgrade">​</a></h3><p>There isn&#x27;t any protocol related backward compabilities changes in 4.7.0. So you can follow the general upgrade sequence to upgrade from 4.6.x to 4.7.0.</p><p>However, we list a list of changes that you might want to know.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="common-configuration-changes">Common Configuration Changes<a href="#common-configuration-changes" class="hash-link" aria-label="Direct link to Common Configuration Changes" title="Direct link to Common Configuration Changes">​</a></h4><p>This section documents the common configuration changes that applied for both clients and servers.</p><h5 class="anchor anchorWithStickyNavbar_LWe7" id="new-settings">New Settings<a href="#new-settings" class="hash-link" aria-label="Direct link to New Settings" title="Direct link to New Settings">​</a></h5><p>Following settings are newly added in 4.7.0.</p><table><thead><tr><th>Name</th><th>Default Value</th><th>Description</th></tr></thead><tbody><tr><td>allowShadedLedgerManagerFactoryClass</td><td>false</td><td>The allows bookkeeper client to connect to a bookkeeper cluster using a shaded ledger manager factory</td></tr><tr><td>shadedLedgerManagerFactoryClassPrefix</td><td><code>dlshade.</code></td><td>The shaded ledger manager factory prefix. This is used when <code>allowShadedLedgerManagerFactoryClass</code> is set to true</td></tr><tr><td>metadataServiceUri</td><td>null</td><td>metadata service uri that bookkeeper is used for loading corresponding metadata driver and resolving its metadata service location</td></tr><tr><td>permittedStartupUsers</td><td>null</td><td>The list of users are permitted to run the bookie process. Any users can run the bookie process if it is not set</td></tr></tbody></table><h5 class="anchor anchorWithStickyNavbar_LWe7" id="deprecated-settings">Deprecated Settings<a href="#deprecated-settings" class="hash-link" aria-label="Direct link to Deprecated Settings" title="Direct link to Deprecated Settings">​</a></h5><p>There are no common settings deprecated at 4.7.0.</p><h5 class="anchor anchorWithStickyNavbar_LWe7" id="changed-settings">Changed Settings<a href="#changed-settings" class="hash-link" aria-label="Direct link to Changed Settings" title="Direct link to Changed Settings">​</a></h5><p>There are no common settings whose default value are changed at 4.7.0.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="server-configuration-changes">Server Configuration Changes<a href="#server-configuration-changes" class="hash-link" aria-label="Direct link to Server Configuration Changes" title="Direct link to Server Configuration Changes">​</a></h4><h5 class="anchor anchorWithStickyNavbar_LWe7" id="new-settings-1">New Settings<a href="#new-settings-1" class="hash-link" aria-label="Direct link to New Settings" title="Direct link to New Settings">​</a></h5><p>Following settings are newly added in 4.7.0.</p><table><thead><tr><th>Name</th><th>Default Value</th><th>Description</th></tr></thead><tbody><tr><td>verifyMetadataOnGC</td><td>false</td><td>Whether the bookie is configured to double check the ledgers&#x27; metadata prior to garbage collecting them</td></tr><tr><td>auditorLedgerVerificationPercentage</td><td>0</td><td>The percentage of a ledger (fragment)&#x27;s entries will be verified by Auditor before claiming a ledger (fragment) is missing</td></tr><tr><td>numHighPriorityWorkerThreads</td><td>8</td><td>The number of threads that should be used for high priority requests (i.e. recovery reads and adds, and fencing). If zero, reads are handled by Netty threads directly.</td></tr><tr><td>useShortHostName</td><td>false</td><td>Whether the bookie should use short hostname or <a href="https://en.wikipedia.org/wiki/Fully_qualified_domain_name" target="_blank" rel="noopener noreferrer">FQDN</a> hostname for registration and ledger metadata when useHostNameAsBookieID is enabled.</td></tr><tr><td>minUsableSizeForEntryLogCreation</td><td>1.2 * <code>logSizeLimit</code></td><td>Minimum safe usable size to be available in ledger directory for bookie to create entry log files (in bytes).</td></tr><tr><td>minUsableSizeForHighPriorityWrites</td><td>1.2 * <code>logSizeLimit</code></td><td>Minimum safe usable size to be available in ledger directory for bookie to accept high priority writes even it is in readonly mode.</td></tr></tbody></table><h5 class="anchor anchorWithStickyNavbar_LWe7" id="deprecated-settings-1">Deprecated Settings<a href="#deprecated-settings-1" class="hash-link" aria-label="Direct link to Deprecated Settings" title="Direct link to Deprecated Settings">​</a></h5><p>Following settings are deprecated since 4.7.0.</p><table><thead><tr><th>Name</th><th>Description</th></tr></thead><tbody><tr><td>registrationManagerClass</td><td>The registration manager class used by server to discover registration manager. It is replaced by <code>metadataServiceUri</code>.</td></tr></tbody></table><h5 class="anchor anchorWithStickyNavbar_LWe7" id="changed-settings-1">Changed Settings<a href="#changed-settings-1" class="hash-link" aria-label="Direct link to Changed Settings" title="Direct link to Changed Settings">​</a></h5><p>The default values of following settings are changed since 4.7.0.</p><table><thead><tr><th>Name</th><th>Old Default Value</th><th>New Default Value</th><th>Notes</th></tr></thead><tbody><tr><td>numLongPollWorkerThreads</td><td>10</td><td>0</td><td>If the number of threads is zero or negative, bookie can fallback to use read threads for long poll. This allows not creating threads if application doesn&#x27;t use long poll feature.</td></tr></tbody></table><h4 class="anchor anchorWithStickyNavbar_LWe7" id="client-configuration-changes">Client Configuration Changes<a href="#client-configuration-changes" class="hash-link" aria-label="Direct link to Client Configuration Changes" title="Direct link to Client Configuration Changes">​</a></h4><h5 class="anchor anchorWithStickyNavbar_LWe7" id="new-settings-2">New Settings<a href="#new-settings-2" class="hash-link" aria-label="Direct link to New Settings" title="Direct link to New Settings">​</a></h5><p>Following settings are newly added in 4.7.0.</p><table><thead><tr><th>Name</th><th>Default Value</th><th>Description</th></tr></thead><tbody><tr><td>maxNumEnsembleChanges</td><td>Integer.MAX<!-- -->_<!-- -->VALUE</td><td>The max allowed ensemble change number before sealing a ledger on failures</td></tr><tr><td>timeoutMonitorIntervalSec</td><td>min(<code>addEntryTimeoutSec</code>, <code>addEntryQuorumTimeoutSec</code>, <code>readEntryTimeoutSec</code>)</td><td>The interval between successive executions of the operation timeout monitor, in seconds</td></tr><tr><td>ensemblePlacementPolicyOrderSlowBookies</td><td>false</td><td>Flag to enable/disable reordering slow bookies in placement policy</td></tr></tbody></table><h5 class="anchor anchorWithStickyNavbar_LWe7" id="deprecated-settings-2">Deprecated Settings<a href="#deprecated-settings-2" class="hash-link" aria-label="Direct link to Deprecated Settings" title="Direct link to Deprecated Settings">​</a></h5><p>Following settings are deprecated since 4.7.0.</p><table><thead><tr><th>Name</th><th>Description</th></tr></thead><tbody><tr><td>clientKeyStoreType</td><td>Replaced by <code>tlsKeyStoreType</code></td></tr><tr><td>clientKeyStore</td><td>Replaced by <code>tlsKeyStore</code></td></tr><tr><td>clientKeyStorePasswordPath</td><td>Replaced by <code>tlsKeyStorePasswordPath</code></td></tr><tr><td>clientTrustStoreType</td><td>Replaced by <code>tlsTrustStoreType</code></td></tr><tr><td>clientTrustStore</td><td>Replaced by <code>tlsTrustStore</code></td></tr><tr><td>clientTrustStorePasswordPath</td><td>Replaced by <code>tlsTrustStorePasswordPath</code></td></tr><tr><td>registrationClientClass</td><td>The registration client class used by client to discover registration service. It is replaced by <code>metadataServiceUri</code>.</td></tr></tbody></table><h5 class="anchor anchorWithStickyNavbar_LWe7" id="changed-settings-2">Changed Settings<a href="#changed-settings-2" class="hash-link" aria-label="Direct link to Changed Settings" title="Direct link to Changed Settings">​</a></h5><p>The default values of following settings are changed since 4.7.0.</p><table><thead><tr><th>Name</th><th>Old Default Value</th><th>New Default Value</th><th>Notes</th></tr></thead><tbody><tr><td>enableDigestTypeAutodetection</td><td>false</td><td>true</td><td>Autodetect the digest type and passwd when opening a ledger. It will ignore the provided digest type, but still verify the provided passwd.</td></tr></tbody></table><h3 class="anchor anchorWithStickyNavbar_LWe7" id="47x-to-48x-upgrade">4.7.x to 4.8.X upgrade<a href="#47x-to-48x-upgrade" class="hash-link" aria-label="Direct link to 4.7.x to 4.8.X upgrade" title="Direct link to 4.7.x to 4.8.X upgrade">​</a></h3><p>In 4.8.x a new feature is added to persist explicitLac in FileInfo and explicitLac entry in Journal. (Note: Currently this feature is not available if your ledgerStorageClass is DbLedgerStorage, ISSUE #1533 is going to address it) Hence current journal format version is bumped to 6 and current FileInfo header version is bumped to 1. But since default config values of &#x27;journalFormatVersionToWrite&#x27; and &#x27;fileInfoFormatVersionToWrite&#x27; are set to older versions, this feature is off by default. To enable this feature those config values should be set to current versions. Once this is enabled then we cannot rollback to previous Bookie versions (4.7.x and older), since older version code would not be able to deal with explicitLac entry in Journal file while replaying journal and also reading Header of Index files / FileInfo would fail reading Index files with newer FileInfo version. So in summary, it is a non-rollbackable feature and it applies even if explicitLac is not being used.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="45x-to-46x-upgrade">4.5.x to 4.6.x upgrade<a href="#45x-to-46x-upgrade" class="hash-link" aria-label="Direct link to 4.5.x to 4.6.x upgrade" title="Direct link to 4.5.x to 4.6.x upgrade">​</a></h3><p>There isn&#x27;t any protocol related backward compabilities changes in 4.6.x. So you can follow the general upgrade sequence to upgrade from 4.5.x to 4.6.x.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="44x-to-45x-upgrade">4.4.x to 4.5.x upgrade<a href="#44x-to-45x-upgrade" class="hash-link" aria-label="Direct link to 4.4.x to 4.5.x upgrade" title="Direct link to 4.4.x to 4.5.x upgrade">​</a></h3><p>There isn&#x27;t any protocol related backward compabilities changes in 4.5.0. So you can follow the general upgrade sequence to upgrade from 4.4.x to 4.5.x.
However, we list a list of things that you might want to know.</p><ol><li>4.5.x upgrades netty from 3.x to 4.x. The memory usage pattern might be changed a bit. Netty 4 uses more direct memory. Please pay attention to your memory usage
and adjust the JVM settings accordingly.</li><li><code>multi journals</code> is a non-rollbackable feature. If you configure a bookie to use multiple journals on 4.5.x you can not roll the bookie back to use 4.4.x. You have
to take a bookie out and recover it if you want to rollback to 4.4.x.</li></ol><p>If you are planning to upgrade a non-secured cluster to a secured cluster enabling security features in 4.5.0, please read <a href="/docs/4.8.2/security/overview">BookKeeper Security</a> for more details.</p></div></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/docs/4.8.2/admin/metrics"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Metric collection</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/docs/4.8.2/admin/http"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">BookKeeper Admin REST API</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#overview" class="table-of-contents__link toc-highlight">Overview</a></li><li><a href="#canary" class="table-of-contents__link toc-highlight">Canary</a><ul><li><a href="#rollback-canaries" class="table-of-contents__link toc-highlight">Rollback Canaries</a></li></ul></li><li><a href="#upgrade-steps" class="table-of-contents__link toc-highlight">Upgrade Steps</a><ul><li><a href="#upgrade-bookies" class="table-of-contents__link toc-highlight">Upgrade Bookies</a></li></ul></li><li><a href="#upgrade-guides" class="table-of-contents__link toc-highlight">Upgrade Guides</a><ul><li><a href="#46x-to-470-upgrade" class="table-of-contents__link toc-highlight">4.6.x to 4.7.0 upgrade</a></li><li><a href="#47x-to-48x-upgrade" class="table-of-contents__link toc-highlight">4.7.x to 4.8.X upgrade</a></li><li><a href="#45x-to-46x-upgrade" class="table-of-contents__link toc-highlight">4.5.x to 4.6.x upgrade</a></li><li><a href="#44x-to-45x-upgrade" class="table-of-contents__link toc-highlight">4.4.x to 4.5.x upgrade</a></li></ul></li></ul></div></div></div></div></main></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="row footer__links"><div class="col footer__col"><div class="footer__title">Documentation</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/docs/overview">Overview</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/getting-started/installation">Getting started</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/deployment/manual">Deployment</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/admin/bookies">Administration</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/api/overview">API</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/security/overview">Security</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/development/protocol">Development</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/reference/config">Reference</a></li></ul></div><div class="col footer__col"><div class="footer__title">Community</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/community/mailing-lists">Mailing lists</a></li><li class="footer__item"><a class="footer__link-item" href="/community/slack">Slack</a></li><li class="footer__item"><a href="https://github.com/apache/bookkeeper" target="_blank" rel="noopener noreferrer" class="footer__link-item">Github<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://twitter.com/asfbookkeeper" target="_blank" rel="noopener noreferrer" class="footer__link-item">Twitter<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">Project</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/project/who">Who are we?</a></li><li class="footer__item"><a class="footer__link-item" href="/project/bylaws">Bylaws</a></li><li class="footer__item"><a href="https://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 class="footer__link-item" href="/project/privacy">Privacy policy</a></li><li class="footer__item"><a href="https://www.apache.org/foundation/sponsorship.html" 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><li class="footer__item"><a href="https://www.apache.org/foundation/thanks.html" 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></ul></div></div><div class="footer__bottom text--center"><div class="footer__copyright"><footer class="footer">
        <div class="container">
          <div class="content has-text-centered">
            <p>
              Copyright &copy; 2016 - 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>,<br> licensed under the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, version 2.0</a>.
            </p>
            <p>
              Apache BookKeeper, BookKeeper®, Apache®, the Apache feature logo, and the Apache BookKeeper logo are either registered trademarks or trademarks of The Apache Software Foundation.
            </p>
          </div>
        </div>
      </footer>
      </div></div></div></footer></div>
<script src="/assets/js/runtime~main.793d926f.js"></script>
<script src="/assets/js/main.c5d52852.js"></script>
</body>
</html>