Community Edition Core Limit

Redpanda Community Edition runs clusters of up to 50 cores in total without an Enterprise Edition license. Starting in 26.3, Redpanda adds up the cores of every broker in the cluster and treats a cluster above the limit as one that uses an enterprise feature, named cluster_cores_over_limit. An over-limit cluster keeps running and serving clients, but Redpanda logs license reminders and refuses upgrades to the next feature release until you install a license or reduce the core count. This is the same treatment that any other enterprise feature, such as Tiered Storage, gets without a license. Understanding how Redpanda counts cores helps you size a Community Edition cluster and confirm that it complies before you plan an upgrade.

The Redpanda Community Edition License sets the 50-core limit across all the clusters, environments, and regions that your organization runs, not for each cluster. Redpanda checks only the cluster that it runs in. So a cluster that passes the check can still be out of compliance with the license if your organization runs other clusters.

After reading this page, you will be able to:

  • Explain how Redpanda counts the cores in a cluster

  • Describe what happens when a cluster without a license exceeds the core limit

  • Identify the ways to bring a cluster within the limit

How Redpanda counts cores

A core is a Redpanda shard. Each broker runs one shard for each core it uses:

  • If you start Redpanda with the --smp flag, the broker uses that number of cores.

  • If you don’t set --smp, the broker uses every core available to the Redpanda process.

Each hyperthread counts as one core. So a host with 16 physical cores and hyperthreading enabled gives a broker 32 cores if you don’t set --smp.

The cores that count for each broker depend on how you deploy Redpanda:

Deployment Cores that count for each broker

Linux, with --smp

The --smp value.

Linux, without --smp

Every core and hyperthread available to the Redpanda process on the host.

Kubernetes

The --smp value that the Helm chart or the Redpanda Operator sets from the broker’s CPU resources.

Redpanda adds up the cores of every broker that is a member of the cluster. A broker that is down, or that you are decommissioning, still counts until it leaves the cluster’s member list. To stop counting a broker, finish decommissioning it.

In Kubernetes, the Redpanda Helm chart and the Redpanda Operator set --smp from the CPU resources of each broker. For details, see Manage Pod Resources in Kubernetes.

A cluster of exactly 50 cores is within the limit. For example:

  • Three brokers with 16 cores each run 48 cores, which is within the limit.

  • Three brokers with 17 cores each run 51 cores, which exceeds the limit.

  • Adding a fourth broker with 16 cores to the first cluster raises the total to 64 cores, which exceeds the limit.

When the limit applies

The limit applies only when no valid license is in effect:

  • During the 30-day trial that every new cluster receives, the limit does not apply.

  • With a valid Enterprise Edition license or trial license key, the limit does not apply. A cluster above 50 cores reports cluster_cores_over_limit as an enterprise feature in use, not as a violation.

  • After the trial or license expires, or if the cluster has no license, the limit applies.

For details about trials and license keys, see Redpanda Licenses and Enterprise Features.

What happens when a cluster exceeds the limit

A cluster above the limit without a valid license behaves like a cluster that uses any other enterprise feature without a license:

  • Every rpk command that connects to the Admin API prints a warning that starts with WARNING: The following Enterprise features are being used in your Redpanda cluster and lists them. The warning repeats on every such command until the cluster is back in compliance.

  • The cluster keeps running and serving clients. No broker is stopped or throttled. Adding brokers, decommissioning brokers, and patch upgrades, such as 26.3.1 to 26.3.2, work as usual.

  • Every five minutes, each broker logs a license reminder that names the cluster_cores_over_limit feature, the cluster’s core total, and the brokers it counted.

  • rpk cluster license info reports License violation: true, lists cluster_cores_over_limit under Enterprise features in use, and shows the cluster’s core total against the limit, for example Cluster cores: 51 / 50 (Community Edition limit). For details, see Check License Status and Feature Usage with rpk.

  • Redpanda refuses upgrades to the next feature release.

A cluster reaches this state in one of two ways. The difference is when and how you find out. Figure 1, “How a cluster exceeds the core limit” shows both paths: an upgrade to 26.3 is refused as soon as the first broker starts on the new version, while a cluster that grows past the limit on 26.3 keeps running and logs reminders until its next feature-release upgrade.

%%{init: {"flowchart": {"padding": 24, "wrappingWidth": 260}}}%% flowchart TB classDef state stroke:#374D7C, fill:#E2EBFF,rx:5,ry:5 classDef stop stroke:#9B2C2C, fill:#FDE8E8,rx:5,ry:5 A["26.2 cluster above 50 cores, no license
(26.2 reports no violation)"]:::state --> B[Start the first broker on 26.3]:::state B --> C["That broker refuses to start.
Other brokers keep serving on 26.2."]:::stop D[26.3 cluster within the limit]:::state --> E["Add a broker or raise --smp
above 50 cores, no license"]:::state E --> F["Cluster keeps serving.
Reminders every 5 minutes."]:::state F --> G[Start the first broker on the next feature release]:::state G --> C2["That broker refuses to start.
Other brokers keep serving."]:::stop
Figure 1. How a cluster exceeds the core limit

Upgrade to 26.3 above the limit

The first broker that you start on 26.3 checks the cluster, finds it above the limit, logs the reason, and exits a few seconds after it starts. The other brokers keep serving reads and writes on 26.2, and the refused broker’s data is untouched. The cluster’s active version stays at 26.2, so the upgrade has not really started. For more about how the active version moves during an upgrade, see How upgrade finalization works.

In Kubernetes, the rolling upgrade stops at the first replaced Pod.

To resume the upgrade, see Recover from a refused upgrade.

Grow above the limit on 26.3

A cluster that was within the limit when it moved to 26.3 can grow above the limit later, when you add a broker or give brokers more cores. Redpanda doesn’t refuse the new broker or stop anything. Instead, the cluster logs reminders and rpk reports the violation. The upgrade to the next feature release is refused until you bring the cluster within the limit or install a license.

Check the core count before you upgrade from 26.2

Before you upgrade a cluster without a valid license from 26.2 to 26.3, you must check the cluster’s core count. Redpanda 26.2 does not know about the limit, so a cluster that reports no problems on 26.2 can still refuse the upgrade.

Only the 26.3 binary counts cores against the limit. The following output comes from the same 51-core cluster without a license, before and after the upgrade:

rpk cluster license info on 26.2 rpk cluster license info on 26.3
LICENSE INFORMATION
===================
License status:     not_present
License violation:  false

No Cluster cores row and no violation.

WARNING: The following Enterprise features are being used in your Redpanda cluster: [cluster_cores_over_limit]. These features require a license.
LICENSE INFORMATION
===================
License status:              not_present
License violation:           true
Cluster cores:               51 / 50 (Community Edition limit)
Enterprise features in use:  [cluster_cores_over_limit]

The first 26.3 broker refuses to start.

To check the core count on 26.2:

  1. Run the following command with rpk 26.2.1 or later:

    rpk cluster info -b --detailed

    In Kubernetes, run the command inside a broker’s container:

    kubectl exec <pod-name> --namespace <namespace> -c redpanda -- \
      rpk cluster info -b --detailed
  2. Add up the values in the CORES column for every broker in the list.

  3. If the total is more than 50 and the cluster has no valid license, install a license or bring the cluster within the limit before you upgrade.

Check the core count on 26.3 or later

On 26.3 or later, Redpanda counts the cores against the limit for you, so you don’t need to add them up. Check the cluster before each upgrade to a new feature release, and after you add brokers or give brokers more cores.

Run the following command:

rpk cluster license info

The Cluster cores row shows the cluster’s core total against the limit. If the cluster has no valid license and runs more than 50 cores, the output reports License violation: true and lists cluster_cores_over_limit under Enterprise features in use. See the 26.3 example in Check the core count before you upgrade from 26.2. Redpanda refuses the next feature-release upgrade until you install a license or bring the cluster within the limit.

In Kubernetes, starting in Redpanda Operator 26.3.1, get the Redpanda resource with the wide output:

kubectl get redpanda <cluster-name> --namespace <namespace> -o wide

The wide output adds the License Type, Expires, License Violation, and Enterprise Features columns to the License column. A cluster above the limit without a valid license shows true in License Violation and cluster_cores_over_limit in Enterprise Features.

For example, kubectl get redpandas --namespace <namespace> -o wide lists every cluster in the namespace. Here, the community cluster uses no enterprise features and is within the limit. The upgrading cluster has no license, runs more than 50 cores, and also uses audit logging, so its upgraded broker refused to start:

NAME        LICENSE TYPE   EXPIRES                LICENSE VIOLATION   ENTERPRISE FEATURES                                       READY   STATUS                              LICENSE
community                                         false               []                                                        True    Cluster ready to service requests   No cluster license is present
upgrading                                         true                ["audit_logging","cluster_cores_over_limit"]              False   Cluster ready to service requests   redpanda-2 refused to start without an Enterprise license for: audit_logging, cluster_cores_over_limit; Redpanda's crash loop limit holds redpanda-2 until startup_log is deleted from the data directory or an hour passes

Bring a cluster within the limit

To bring a cluster within the limit, do one of the following:

Recover from a refused upgrade

If a broker refused to start on the new version, the other brokers keep serving on the previous version, and the upgrade hasn’t finalized. Do one of the following, in order of preference. Figure 2, “Recover from a refused upgrade” shows the three paths.

  1. Install a license. Install an Enterprise Edition license through any running broker, or apply a 30-day trial license with rpk generate license --apply. The license takes effect on the running cluster immediately. Then start the refused broker again on the same new version, and the rolling upgrade continues.

  2. Roll back the refused broker. Put the previous version back on that broker and start it. The cluster returns to normal operation on the previous version with the same data. Upgrade again after you install a license or bring the cluster within the limit.

  3. Bring the cluster within the limit. See Bring a cluster within the limit. Then start the refused broker again on the same new version, and the rolling upgrade continues.

%%{init: {"flowchart": {"padding": 24, "wrappingWidth": 260}}}%% flowchart TB classDef userAction stroke:#374D7C, fill:#E2EBFF,rx:5,ry:5 classDef stop stroke:#9B2C2C, fill:#FDE8E8,rx:5,ry:5 A["Broker refused to start on the new version"]:::stop A --> B["1. Install a license through any running broker
(or apply a trial license)"]:::userAction A --> C["2. Roll back the refused broker
to the previous version"]:::userAction A --> D["3. Bring the cluster to 50 cores or fewer"]:::userAction B --> E[Start the refused broker again on the same new version]:::userAction D --> E E --> F[The rolling upgrade continues]:::userAction C --> G["The cluster runs on the previous version.
Upgrade again after you license or shrink the cluster."]:::userAction
Figure 2. Recover from a refused upgrade

For the full steps on each path, including what to do if the broker reached its crash loop limit, see A Redpanda Enterprise Edition license is required for Linux, or the Kubernetes version.