Support Guide for JRE 17 and JRE 21
SnapLogic adds support for JRE 21 in the August 2026 release (GA: August 12, 2026), building on the JRE 17 support introduced in the May 2026 release. The Snaplex with Java 11 byte code now also runs Java 17 and Java 21 byte code. To change the Java version running on your Groundplex nodes, refer to Configure the JRE Version.
Benefits
Upgrading to JRE 17 or JRE 21 provides:
- Extended support and security updates through September 2029
- Enhanced application performance through improved garbage collection and reduced memory usage
- Access to modern Java features for improved developer productivity
- Strengthened security through enhanced cryptographic libraries and JRE internal encapsulation
Plan
The following versions are supported in the Snaplex JCC:
- JRE 11
- JRE 17
- JRE 21
JRE 17 was certified in the May 2026 release, and JRE 21 is certified in the August 2026 release. The Snaplex with Java 11 byte code can also run Java 17 and Java 21 byte code.
| Version | Snaplex | Snaps |
|---|---|---|
| JRE 11 | Currently certified | Currently certified |
| JRE 17 | Certified May 13, 2026 | Certified May 13, 2026 |
| JRE 21 | Certified August 12, 2026 | Certified August 12, 2026 |
Required Action
| Product Area | SnapLogic Responsibility | Customer Responsibility |
|---|---|---|
| SnapLogic Platform Runtime: Snaplex JCC on JRE 17 | Design, build, certify, and support Snaplex runtime compatibility on JRE 17 (JDK 11 byte code running on JRE 17) Certified in the May 2026 release |
Deploy supported Snaplex versions per guidance |
| SnapLogic Platform Runtime: Snaplex JCC on JRE 21 | Design, build, certify, and support Snaplex runtime compatibility on JRE 21 (JDK 11 byte code running on JRE 21) Certified in the August 2026 release (GA: August 12, 2026) |
Deploy supported Snaplex versions per guidance to run on JRE 21 |
| SnapLogic Snap Packs | Provide full certification, compatibility testing, and support on JRE 17 and JRE 21 | Consume Snaps as delivered |
| Custom Snaps in Private Snap Packs | Provide general constraints, guidance, documentation, and best practices | Develop, test, validate, and certify custom Snaps |
| Execution of JDK 11-Built Custom Snaps on JRE 17 or JRE 21 Snaplex | Certify that the Snaplex can execute Java 11 byte code on JRE 17 and JRE 21 | Confirm full certification and compatibility testing |
FAQ
Is JRE 21 support available?
Yes. JRE 21 support is available in the August 2026 release (GA: August 12, 2026). JRE 17 has been supported since the May 2026 release. We recommend planning your upgrade to JRE 21 to take advantage of extended support and performance improvements.
Do I need to prepare for JRE 17 or JRE 21 support?
Yes, verify support in the endpoints you use in your integrations by checking for fixes and security patches.
Do I need to upgrade my Groundplex nodes to JRE 17 or JRE 21 immediately?
No, you do not need to take any action immediately. JRE 11 and JRE 17 will continue to be supported. However, we recommend planning your upgrade to JRE 21, as older versions will be phased out in a future release.
Can I continue to use only JRE 11 on my Groundplex nodes?
Yes, you can continue to use JRE 11 on your Groundplex nodes. However, eventually you'll need to either update your Groundplex nodes to run on JRE 17 or JRE 21, or reinstall using the JRE 17 or JRE 21 compatible Linux RPM/DEB installer or the Windows equivalent.
Can I upgrade my Groundplex nodes to take advantage of the JRE 17 or JRE 21 support?
Yes, we recommend that you do if you plan to develop custom Snaps using JDK 17 or JDK 21.
Will SnapLogic support an OpenJDK distribution?
Yes, however, while the Snaplex Linux RPM/DEB installers use OpenJDK, we don't limit the support to a specific distribution.
Will support for JRE 11 be phased out in the future?
Yes, we are planning to phase out support and recommend that you start planning to upgrade your Groundplex nodes to run JRE 17 or JRE 21.
Will Custom Snaps developed with JDK 17 or JDK 21 work on the JRE 17 or JRE 21 Snaplex?
SnapLogic does not certify or guarantee compatibility for Custom Snaps. You are responsible for testing all of your Custom Snaps against the target JRE and reporting any errors to us.
Are there any known compatibility considerations or limitations when upgrading from JRE 11 to JRE 17 or JRE 21?
The main consideration is strong encapsulation of internal JDK APIs, introduced as
the default behavior starting with JDK 17. Code that uses reflection to access internal
JDK packages (for example, sun.* or other non-public APIs) is blocked by
default on JRE 17 and JRE 21, and the --illegal-access flag that allowed
this on JRE 9–16 has been removed. This mainly affects third-party libraries or Custom
Snaps that haven't been updated for modern JDK encapsulation rules, rather than
SnapLogic-provided Snap Packs, which are certified on both JRE 17 and JRE 21. If a Custom
Snap or dependency fails after upgrading with an InaccessibleObjectException
or similar error, see the JVM parameters question below for how to grant explicit access.
Beyond this, JRE 17 and JRE 21 are drop-in replacements for JRE 11 at the Snaplex
runtime level — no changes to pipeline design, Snap configuration, or data processing
behavior are required.
Do I need to change any JVM parameters, security providers, or TLS/SSL configurations when upgrading?
In most cases, no. Specifically:
- JVM parameters: No JVM parameter changes are required for SnapLogic-provided
Snap Packs. If a Custom Snap or third-party library fails with an
InaccessibleObjectExceptionbecause of the JDK 17+ internal-API encapsulation described above, you can grant it access with--add-opensor--add-exportsJVM flags, specific to the module and package the code needs. These must reach the JCC process specifically, not the Monitor process — setting them directly inEXTRA_JVM_OPTIONSapplies them to the Monitor only. Nest the flag inside-Djvm_optionsthe same way other JCC-specific options are forwarded, for example:
See Set a specific IP address for a Groundplex node for the full forwarding pattern (under "JVM options chain") and the equivalent Kubernetes and Docker Compose syntax.EXTRA_JCC_JVM_OPTIONS="--add-opens java.base/sun.nio.ch=ALL-UNNAMED" EXTRA_JVM_OPTIONS="-Djvm_options=\"$EXTRA_JCC_JVM_OPTIONS\"" - Security providers and cryptographic settings: By default, SnapLogic does not
customize or restrict the JDK security provider configuration — you run with whatever
providers and algorithm restrictions ship with the JRE 17 or JRE 21 build you install.
If a pipeline fails with an
InvalidAlgorithmExceptionbecause the default SUN provider can't handle a particular private key, you can override the default provider order to put Bouncy Castle first; see Configure Bouncy Castle as the first security provider in your Snaplex. This override is independent of the JRE version and carries over unchanged when you upgrade to JRE 17 or JRE 21. If your integrations depend on an algorithm that a newer JDK's default security policy disables or restricts (for example, in java.security'sjdk.tls.disabledAlgorithmsorjdk.certpath.disabledAlgorithms), that's a JDK-level policy change independent of SnapLogic, and the standard JDK mechanism for adjusting it still applies. Note that the location of java.security itself changed starting with JDK 9: it now lives in the JRE's conf/security directory, not lib/security — lib/security still holds cacerts and other keystore files, but not java.security. - TLS/SSL configuration: JRE 11, JRE 17, and JRE 21 all support TLS 1.2 and TLS 1.3, and TLS 1.0/1.1 are disabled by default in all three. Upgrading from JRE 11 to JRE 17 or JRE 21 does not change the supported TLS protocol versions or the Snaplex's TLS configuration. You don't need to update any SnapLogic TLS settings as part of this upgrade.
Will the upgrade affect cacerts, serverkeys.jks, custom truststores/keystores, or certificates used for Kafka, HTTPS, or other integrations?
The impact differs by file, because these aren't all stored or managed the same way:
- cacerts: This is the JRE's own trust store, located at <JAVA_HOME>/lib/security/cacerts. Each JRE installation has its own cacerts file. If you've added custom CA certificates to your current JRE 11 cacerts (for example, for an internal certificate authority or a self-signed endpoint), those entries do not carry over automatically when you install JRE 17 or JRE 21 — you need to re-import them into the new JRE's cacerts file. See Import an SSL/TLS Certificate to SnapLogic JCC nodes and Snaplex node customizations, which already documents this as a standard step whenever the JRE version changes.
- jcc-serverkeys.jks / serverkeys.jks: This is a SnapLogic-generated keystore holding the node's unique TLS identity, stored in /etc/snaplogic on Linux or C:\opt\snaplogic\etc on Windows — not inside the JRE installation directory. On a Linux, Windows, or RPM/DEB-upgraded node, it's unaffected by a JRE upgrade: you don't need to regenerate, migrate, or re-import it. Continue to keep this file unique per node and avoid copying it between nodes, as already documented in Prepare nodes. On Docker, this doesn't apply the same way — see the Docker note below.
- Custom truststores/keystores: Any truststore or keystore file you created yourself (for example, a jcc-servertrust.jks file for mutual TLS, per Configure a Groundplex truststore) lives outside the JRE directory. On Linux, Windows, and RPM/DEB upgrades, it's unaffected by the JRE version. JKS-format files remain fully readable on JRE 17 and JRE 21 — the JKS provider ships with every JDK distribution SnapLogic supports, so no file format conversion is required. On Docker, you must preserve this file yourself — see the Docker note below.
- Docker Groundplexes: Upgrading the JRE version on a Docker Groundplex means
replacing the container with one running the new image, not an in-place update. Any
file in the container's writable layer that isn't backed by a persistent volume does
not survive container recreation unless you back it up first and restore it into the
new container before it starts. This affects three different kinds of files, and
they're not interchangeable backups — keep them separate:
- jcc-datakeys.jks and jcc-datakeys.pass
(used for Enhanced Account Encryption): follow the Docker key backup and restore steps before starting the upgraded
container. If you're using Enhanced Account Encryption and skip this step, the
replacement container generates its own unrelated data keys and can no longer
decrypt the environment's existing accounts. That procedure explicitly excludes
jcc-serverkeys.jks — don't substitute one for the
other.
CAUTION: The Enhanced Account Encryption prerequisites currently require Groundplex nodes to run a Java 11 JRE. Before upgrading a node with Enhanced Account Encryption enabled to JRE 17 or JRE 21, confirm with SnapLogic support that your target JRE is supported for EAE — don't assume compatibility from this guide alone.
- jcc-serverkeys.jks and jcc-serverkeys.pass
(the node's TLS identity): back these up and restore them into the replacement
container for that same node, before it starts:
Restoring jcc-serverkeys.jks without its matching jcc-serverkeys.pass leaves the replacement node unable to load the keystore — always back up and restore both files together. Only restore these files into the replacement for the same node — never copy them to a different node's container.mkdir -m 700 -p ~/serverkeys-backup docker cp source_container:/etc/snaplogic/jcc-serverkeys.jks ~/serverkeys-backup/ docker cp source_container:/etc/snaplogic/jcc-serverkeys.pass ~/serverkeys-backup/Restoring into the replacement container
Use a single
docker create/docker startcycle to restore every backed-up file before the container starts — don't run a separate create/start cycle per file type, sincedocker createfails on a container name that already exists, and starting the container before every key pair is copied in defeats the purpose of usingdocker createin the first place. If this node also has Enhanced Account Encryption enabled, combine the datakeys copy commands from the data-key restore procedure into this same sequence:docker create --name new_container other options image docker cp ~/serverkeys-backup/jcc-serverkeys.jks new_container:/etc/snaplogic/jcc-serverkeys.jks docker cp ~/serverkeys-backup/jcc-serverkeys.pass new_container:/etc/snaplogic/jcc-serverkeys.pass docker cp ~/eae-key-backup/jcc-datakeys.jks new_container:/etc/snaplogic/jcc-datakeys.jks docker cp ~/eae-key-backup/jcc-datakeys.pass new_container:/etc/snaplogic/jcc-datakeys.pass docker start new_containerOmit the two datakeys lines if Enhanced Account Encryption isn't enabled on this node. Use
docker createrather thandocker runso the container exists but hasn't started yet, giving you a chance to copy every file in first. - Custom truststores/keystores you mounted into the container: back these up and restore them the same way, together with any password file they require.
- jcc-datakeys.jks and jcc-datakeys.pass
(used for Enhanced Account Encryption): follow the Docker key backup and restore steps before starting the upgraded
container. If you're using Enhanced Account Encryption and skip this step, the
replacement container generates its own unrelated data keys and can no longer
decrypt the environment's existing accounts. That procedure explicitly excludes
jcc-serverkeys.jks — don't substitute one for the
other.
- Certificates for Kafka, HTTPS, or other integrations: Snap accounts that use SSL/TLS (such as the Kafka SSL account) reference their own explicit Truststore and Keystore file paths as account properties, independent of the JRE's default cacerts. These account-level files are unaffected by a JRE upgrade. The exception is any integration that relies on the JRE's default cacerts trust store rather than an account-specific truststore — for those, follow the cacerts guidance above and re-import any custom CA certificates after installing JRE 17 or JRE 21.
Are there certificate migration or truststore update steps required when moving to JRE 17 or JRE 21?
On Linux, Windows, and RPM/DEB upgrades, the only required step is re-importing any custom CA certificates into the new JRE's cacerts file, since cacerts is per-JRE-install and not shared across JRE versions. No migration or conversion is needed for jcc-serverkeys.jks, Kafka or other Snap account truststores/keystores, or any other file stored outside the JRE directory on these platforms — they continue to work as-is. On Docker, back up and restore these same files as part of the container replacement — see the Docker Groundplexes item above.
- Before upgrading a node, list the custom CA certificates currently imported into its
JRE 11 cacerts file, using the
keytool -listcommand. - For each custom certificate, make sure you have a durable copy of the actual
certificate file (not just the listing) to re-import later. If you don't have the
original PEM file on hand, export it from the current cacerts
before upgrading:
Store the exported files somewhere outside the node — listing the certificates alone doesn't preserve the material you need for the next steps.keytool -exportcert -keystore <old-JAVA_HOME>/lib/security/cacerts -alias <alias> -rfc -file <alias>.pem - Install JRE 17 or JRE 21 per Configure the JRE Version.
- Re-import each custom CA certificate (from its original PEM or the file you exported in step 2) into the new JRE's cacerts file.
- Restart the JCC node and confirm the imported certificates with
keytool -listagainst the new JRE's cacerts path.
What's the overall impact and what should I do before planning the upgrade?
For most environments, upgrading from JRE 11 to JRE 17 or JRE 21 is a low-impact, node-level change — SnapLogic Snap Packs are fully certified on both, and your pipeline designs, Snap configurations, and TLS settings don't need to change. Before you plan the upgrade:
- Inventory any Custom Snaps or third-party libraries, and test them against the target
JRE — SnapLogic doesn't certify Custom Snap compatibility (see the Custom Snaps
question above). Watch specifically for
InaccessibleObjectExceptionerrors, which indicate the code needs--add-opensor--add-exportsJVM flags. - Identify any node-level customizations that need to be reapplied after installing the new JRE, especially custom CA certificates in cacerts, per Snaplex node customizations.
- Follow the standard rollout approach: upgrade development and testing Orgs first, verify pipeline behavior, then upgrade one production node at a time with nodes in Maintenance mode, per Configure the JRE Version.
- On Linux, Windows, and RPM/DEB upgrades, no changes are required to jcc-serverkeys.jks, Kafka or other Snap account truststores/keystores, or your Snaplex's TLS/security provider configuration. On Docker Groundplexes, plan to back up and restore these files — and any Enhanced Account Encryption data keys — as part of the container replacement, per the Docker Groundplexes item above.