• Facebook
  • Twitter
  • Youtube
  • LinkedIn
  • RSS
  • Docs
  • Comparisons
  • Blogs
  • Try NCache
  • Contact Us
Try NCache
Show / Hide Table of Contents

Configure TLS Encryption in Windows and Linux

NCache supports Transport Layer Security (TLS) to encrypt communication between clients, cache servers, cluster nodes, Bridges, and management components. It provides a unified TLS configuration for Windows and Linux using PEM-formatted certificates, eliminating the need to identify certificates through Common Names (CNs) or thumbprints.

NCache supports TLS to encrypt communication and authenticate servers, and Mutual TLS (mTLS) to additionally authenticate connecting clients using certificates. Both modes support the following server certificate options:

  • NCache-provided certificates: Automatically generated, signed, managed, and renewed by NCache without requiring manual certificate provisioning.
  • Custom certificates: Issued by your organization's Certificate Authority (CA), with certificate provisioning, trust, and renewal managed by your organization.

NCache-Provided Certificates

NCache automatically provisions and manages server certificates through its certificate-signing service, eliminating the need for manual certificate provisioning or distribution between server nodes. Each server node receives a unique certificate and retains its private key locally.

Certificate Architecture

NCache-provided certificates use a three-level certificate hierarchy to establish trust between NCache components:

NCache Root CA → Customer Intermediate CA → Server Leaf Certificate

Each level serves a specific purpose in the certificate-signing and validation process:

  • Root CA: Alachisoft maintains the NCache Root CA, which signs customer Intermediate CA certificates. Its public certificate is included with NCache Server and Client SDK installations, allowing NCache components to validate certificates issued through this hierarchy.
  • Intermediate CA: Each customer is assigned a separate Intermediate CA when TLS is first enabled using NCache-provided certificates or a client certificate is first generated by NCache, whichever occurs first. The same Intermediate CA is reused across the customer's deployments, while its private key remains protected within Alachisoft's certificate-signing infrastructure.
  • Leaf certificate: Each NCache server node receives a unique leaf certificate signed by the customer's Intermediate CA. The corresponding private key is generated and stored locally on the server node.

Certificate Issuance Process

When TLS or Mutual TLS is enabled using NCache-provided server certificates, NCache automatically performs the following operations on each participating server node:

  1. Generate the certificate request: The node generates a unique private key and Certificate Signing Request (CSR). The private key remains on the node and is never sent to Alachisoft.
  2. Submit the signing request: NCache sends only the CSR to its certificate-signing service, where the customer's Intermediate CA is used to sign the request.
  3. Receive the signed certificate: The signing service returns the signed leaf certificate and Intermediate CA certificate to the requesting node.
  4. Store the certificate: NCache creates leaf.pem in the node's certificate directory. The file contains the private key, signed leaf certificate, and Intermediate certificate chain, in that order.

Once the certificate is available, the server presents its certificate chain during TLS communication. The connecting NCache component validates the chain against the NCache Root CA public certificate included with its installation or Client SDK. This establishes trust without requiring manual installation of the NCache Root CA for those components.

Throughout this process, server private keys remain on their respective nodes, while Intermediate CA private keys remain within Alachisoft's signing infrastructure. Only public certificates and certificate issuance or renewal metadata are stored centrally.

Automatic Certificate Renewal

NCache automatically renews NCache-provided server certificates to maintain TLS communication without requiring manual certificate replacement. Server leaf certificates are valid for two years, and each node independently checks its certificate expiration every 12 hours.

When 30 days or fewer remain before expiration, the node generates a new private key and Certificate Signing Request (CSR). It then contacts the certificate-signing service over HTTPS, using the customer's NCache license to authenticate the request. After receiving the renewed certificate, NCache updates the local certificate file and loads the new certificate into memory without restarting the server.

If renewal fails, NCache logs the error and retries during the next scheduled check. The existing certificate remains in use while valid, and each server node manages its renewal independently.

Custom Certificates

In addition to NCache-provided certificates, NCache supports PEM-formatted certificates issued by your organization's Certificate Authority (CA). This option allows organizations to use their existing certificate-management infrastructure and security policies.

To configure a custom certificate, provide a PEM file containing the private key, server leaf certificate, and Intermediate certificates, in that order. The file must be accessible on every applicable server node, and the issuing Root CA must be trusted through the operating-system trust store or a certificate in the custom certificate directory.

Unlike NCache-provided certificates, custom certificates are not automatically issued or renewed by NCache. Your organization is responsible for certificate provisioning, private-key protection, trust configuration, and renewal.

For configuration instructions, see Configure TLS Using Custom Certificates.

TLS Communication

NCache supports TLS and Mutual TLS (mTLS). Both encrypt data in transit, but they differ in whether the connecting client must present a certificate.

TLS

TLS encrypts the connection and lets the client authenticate the NCache server. During the TLS handshake, the server presents its certificate chain, which the client validates against a trusted Root CA. The client does not need to present its own certificate. TLS supports either NCache-provided or custom server certificates.

Mutual TLS (mTLS)

Mutual TLS extends TLS by requiring the client to present a valid certificate as well. The client validates the server certificate, and NCache validates the client's certificate against a trusted issuing CA. NCache supports two options for client certificates:

  • NCache-generated client certificate: Generate an Alachisoft-signed certificate using the New-NCacheTlsCertificate PowerShell cmdlet.
  • Custom client certificate: Use a certificate issued by your organization's CA and ensure that the NCache server trusts its issuing Root CA.

When Mutual TLS is enabled, every client application must be configured with a valid client certificate. Configure the client certificate even when the application runs on an NCache server. NCache-generated client certificates are created on the client machine, where their private keys remain. For server-to-server communication, NCache nodes present their own certificate chains and validate their peers without sharing private keys.

Restart Behavior After TLS Configuration Changes

Enabling, disabling, or updating your TLS configuration requires the processes using the configuration to load the updated settings. Thus, the NCache Management Center and the TLS PowerShell cmdlets restart these processes automatically after you confirm the operation. These changes affect the selected nodes and can interrupt client connections for a couple of minutes, so schedule the operation when this interruption is acceptable.

After applying the configuration, NCache performs the following operations:

  • Stops and starts each running cache on its selected node, then stops any running client caches on the selected nodes. Client applications start their client caches again when they reconnect, using the updated settings.
  • Restarts the NCache Execution Service on each selected node where it is running so that cache loaders use the updated TLS settings.
  • Stops running Bridges, restarts the NCache Bridge Service on each selected node where it is running, and starts the Bridges again. Services that were stopped before the operation remain stopped.
Note

The NCache Service does not require a restart because it reloads TLS configuration changes automatically. If a restart step fails after the configuration has been applied, review the reported errors and manually restart the affected components before verifying connectivity.

Client Caches and Client Cache Nodes

A running client cache must be stopped so that it can start with the updated TLS settings. The automatic operation stops running client caches on the selected nodes. If a running client cache is hosted on another machine, stop that client cache on its host as part of applying the TLS change there. This applies to an existing client cache node and to a newly added client cache node if its client cache is already running. Adding a node alone does not require stopping a client cache that has not started.

Client Application Restarts

For TLS without Mutual TLS, an already running client application does not require a restart. When the cache restarts and the client reconnects, the server communicates the TLS requirement and presents its certificate chain during the handshake. Ensure that the client trusts the server certificate's issuing CA; the client does not need its own certificate or a copy of the server's private key.

For Mutual TLS, the client must also present its own valid certificate. If the running application already has the correct client certificate path and any required password loaded, it can reconnect after the cache restart without an application restart. If you add or change tlsCertPath or tlsCertPassword after the client connection has been initialized, restart the application so that it loads the updated certificate settings. The certificate file must be accessible to the application account, and the server must trust its issuing CA.

Configure TLS and Mutual TLS Using the NCache Management Center

The NCache Management Center provides a centralized interface for configuring TLS or Mutual TLS on one or more server nodes. The common steps for selecting the target nodes and enabling TLS are performed once, after which you can choose the required certificate source and optionally enable Mutual TLS.

  • Launch the NCache Management Center by browsing to http://localhost:9801 or <server-ip>:9801.
  • From the left navigation bar, click the Settings Tab button.
  • Under Environment, click TLS Security.
  • In the Select Nodes section, enter the server IP address in the Node IP field and click Add. Repeat this step for every server node on which TLS should be configured. To remove a server, click the remove button against the corresponding node.
  • Under TLS Configuration, select Enable TLS on the selected nodes.

TLS Security Page in NCache Management Center

After adding the required nodes and enabling TLS, configure the certificate source using one of the following options.

Configure TLS Using NCache-Provided Certificates

Use this option when you want NCache to generate, sign, store, and renew the server certificates automatically. No certificate path is required because NCache manages the certificate on each selected server node.

  • Under Certificate Source, select Use NCache certificate.
  • NCache generates a unique key pair and CSR on each selected node, obtains the node-specific leaf certificate, and creates the local leaf.pem file.
  • If Mutual TLS is also required for client connections, first configure the client certificate as described in Configure Mutual TLS, and then enable the Mutual TLS option.

Configure TLS Using an NCache Certificate

  • Complete the protocol selection, click Save, and choose Enable TLS and Restart in the resulting popup.

Popup asking users to enable TLS and restart

This will result in a window showing users which steps are being taken to update their TLS configuration as shown below.

Popup showing users how they are progressing in applying TLS

After TLS is enabled successfully, NCache creates leaf.pem on each selected node under the NCache certificate directory. If TLS is later disabled, the generated certificate file can remain on the machine and may be reused when TLS is enabled again.

Configure TLS Using Custom Certificates

Use the custom certificate option when you want NCache to use a certificate issued by your organization's Certificate Authority (CA). Provide a single PEM file containing the private key, leaf certificate, and any Intermediate certificates in that order, and make sure the configured certificate path is available on every selected server node. NCache must also be able to trust the Root CA that issued the certificate. You can install the Root CA certificate in the operating system's trusted certificate store, such as Trusted Root Certification Authorities on Windows or the system CA trust store on Linux, or place it in the same directory as the custom certificate.

  • Under Certificate Source, select Use custom certificate. The Certificate Path field and private-key password field become available.
  • Enter the absolute path of the PEM file in the Certificate Path field.
  • If its private key is encrypted, enter the password in the Private key password field below the certificate path. Leave this field empty for an unencrypted private key.
  • Make sure the same path exists and is accessible on every selected server node.
  • Verify that the PEM file contains the private key, leaf certificate, and Intermediate certificate or certificates in that order.
  • Ensure that the corresponding Root CA certificate is installed in the operating system's trust store or placed in the same directory as the custom certificate.
  • If Mutual TLS is also required for client connections, configure the client certificate as described in Configure Mutual TLS, and then enable the Mutual TLS option.

Configure a Custom Certificate for TLS

Complete the protocol selection, click Save, and choose Enable TLS and Restart in the resulting popup.

Important

Protect the private key in the custom PEM file and restrict access to the account that runs the corresponding NCache process. An encrypted key requires the correct password to load. A missing or incorrect password causes certificate loading to fail; passwords are not included in error messages or logs. The password is saved with the custom certificate settings in tls.ncconf and cleared when you switch to an NCache-provided certificate. Protect exported TLS configurations because they include the configured password.

Configure Mutual TLS

Mutual TLS requires connecting clients to present a valid client certificate in addition to validating the server certificate. Configure the client certificate first using one of the following options, then enable the Mutual TLS option for the required server nodes through the NCache Management Center. The Management Center does not require you to supply a separate client certificate to enable Mutual TLS. Client applications must still be configured with their own client certificates.

Option 1: Use an NCache-Generated Client Certificate

NCache provides the New-NCacheTlsCertificate PowerShell cmdlet to generate an Alachisoft-signed client certificate. Run the cmdlet on the machine where the client application runs so that the private key is generated and retained locally on that machine.

New-NCacheTlsCertificate -Server <server> -Path <full-file-path.pem>

For example:

New-NCacheTlsCertificate -Server 20.200.20.11 -Path C:\certs\client.pem

The -Path parameter specifies where the generated certificate is stored. The -Server parameter is mandatory and specifies the registered NCache server used to obtain the required registration information, regardless of whether the cmdlet is executed on a server or client machine. The -Path parameter specifies the location where the generated client certificate is saved.

If the target file already exists and you want to issue a new client certificate, use the -Force parameter:

New-NCacheTlsCertificate -Server 20.200.20.11 -Path C:\certs\client.pem -Force

After successful generation, the client PEM file is created at the specified location. The private key remains on the client machine and is not sent outside the system.

Option 2: Use a Certificate Issued by Your Own CA

You can also use a client certificate issued by your organization's Certificate Authority (CA). Obtain the client certificate through your organization's certificate-management process and keep the resulting PEM file on the machine where the client application runs.

For this option, make sure that every NCache server trusts the Root CA that issued the client certificate. Restrict access to the PEM file so that only the account running the client application can access its private key.

After obtaining the client certificate through either option, set tlsCertPath in the cache-name entry within the ncache section of the client application's appsettings.json to the certificate path. For .NET Core / modern .NET, use a PEM file. .NET Framework clients support only PFX certificates. If the certificate's private key is encrypted, or a PFX file is password-protected, supply tlsCertPassword; otherwise omit it. These values can also be set through ConnectionOptions.TLSCertPath and ConnectionOptions.TLSCertPassword, which take precedence over the application configuration.

Install the issuing Root CA certificate in the operating-system trust store on the machine running the ASP.NET Core or .NET Framework application. The server must also trust the client certificate's issuing Root CA. Restrict access to the certificate and its private key to the client application account.

{
  "ncache": {
    "defaultCache": {
      "server": "20.200.20.11,20.200.20.12",
      "tlsCertPath": "C:\\certs\\client.pem",
      "tlsCertPassword": "your-client-key-password"
    }
  }
}

Replace defaultCache with the name of your cache and the server addresses and certificate path with those for your deployment. For an unencrypted PEM file, omit tlsCertPassword from the example. The PEM certificate generated by New-NCacheTlsCertificate contains an unencrypted private key.

Once the client certificate has been generated or obtained and configured in the client application, return to the TLS Security page and select Require clients to present a certificate (Mutual TLS).

Enable Mutual TLS in NCache Management Center

After configuring the required certificate source and Mutual TLS settings, complete the TLS configuration as follows:

  • From the Protocol Version drop-down list, select TLS 1.2 to use TLS 1.2 exclusively, TLS 1.3 to use TLS 1.3 exclusively, or Auto to allow the operating system to negotiate the highest mutually supported TLS version.
  • Click Save. A Restart services to enable TLS? confirmation popup appears for NCache-provided certificates, custom certificates, and Mutual TLS.
  • Click Enable TLS and Restart to apply the configuration to all nodes listed in Select Nodes and perform the required restarts.
  • Wait for the progress dialog to complete the configuration and restart steps, then review the result. If any step fails, review the reported errors and restart the affected components manually.
  • For Mutual TLS, restart the client application only if it needs to load a newly added or changed client certificate path or password. For details, see Client Application Restarts.
Note

The Mutual TLS option controls client certificate authentication for applicable client connections. Inter-node certificate authentication is handled automatically by NCache and does not require a separate client certificate configuration.

Configure TLS and Mutual TLS Using PowerShell

You can also configure TLS or Mutual TLS through PowerShell by using the Enable-NCacheTLS cmdlet. It can enable TLS on the local NCache server or on one or more remote server nodes, and supports NCache-provided certificates, custom certificates, and Mutual TLS.

Before applying a TLS change, the cmdlet displays a restart notice and asks Do you want to continue (Y or N)? Enter Y to apply the settings and perform the automatic restarts, or N to leave the settings and running components unchanged. This console prompt applies to NCache-provided certificates, custom certificates, and Mutual TLS. Specify -Force to apply the change and restart components without asking for confirmation. For the affected components and client application requirements, see Restart Behavior After TLS Configuration Changes.

Enable TLS Using NCache-Provided Certificates

Run Enable-NCacheTLS without specifying a custom certificate path to use NCache-provided server certificates. On successful configuration, each target server node generates its own key pair and obtains its own leaf certificate.

To enable TLS on the local NCache server, run:

Enable-NCacheTLS

To enable TLS on multiple remote nodes, specify the server IP addresses:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12"

If NCache security is enabled on the remote servers, provide the required credentials:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12" -Credentials (Get-Credential)

To specify TLS 1.3 explicitly, use -ProtocolVersion tls13, as shown below. Use tls12 for TLS 1.2 or auto to negotiate the highest mutually supported TLS version:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12" -ProtocolVersion tls13

This command enables Mutual TLS (mTLS) on the specified server using NCache-provided certificates. It runs from a machine where NCache is not installed and uses C:\certs\admin-client.pem to authenticate the machine running the cmdlet. The -TlsCertPassword parameter decrypts the certificate's password-protected private key. Omit this parameter if the private key is not encrypted.

Enable-NCacheTLS -Node "20.200.20.11" `
                 -TlsCertPath "C:\certs\admin-client.pem" `
                 -TlsCertPassword "clientKeyPassword" -UseMutualTls

Enable TLS Using Custom Certificates

Use Enable-NCacheTLS with -CustomCertificatePath when the server should use a certificate supplied by your organization. The PEM file must contain the private key, leaf certificate, and any Intermediate certificates in that order, and the specified path must be valid on every target node.

To configure a custom certificate on the local server, run:

Enable-NCacheTLS -CustomCertificatePath "C:\certs\ncache-chain.pem"

For an encrypted server private key, include -CustomCertificatePassword with the certificate path:

Enable-NCacheTLS -Node "20.200.20.11" `
                 -CustomCertificatePath "C:\certs\server.pem" `
                 -CustomCertificatePassword "your-server-key-password"

To configure the same custom certificate on multiple remote nodes, run:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12" `
                 -CustomCertificatePath "C:\certs\ncache-chain.pem"

This command enables Mutual TLS (mTLS) on the specified server using a custom server certificate. It runs from a machine where NCache is not installed and uses C:\certs\admin-client.pem to authenticate the machine running the cmdlet. The -CustomCertificatePath parameter specifies the server certificate, while -TlsCertPath specifies the client certificate used for the PowerShell connection.

Enable-NCacheTLS -Node "20.200.20.11" `
                 -CustomCertificatePath "C:\certs\server.pem" `
                 -TlsCertPath "C:\certs\admin-client.pem" -UseMutualTls

Before enabling TLS, ensure that the corresponding Root CA certificate is installed in the operating system's trust store or placed in the same directory as the custom certificate.

Configure Mutual TLS Using PowerShell

Before enabling Mutual TLS, generate or obtain the client certificate using one of the options described in Configure Mutual TLS. To generate an NCache-signed client certificate, use the New-NCacheTlsCertificate cmdlet on the machine where the client application runs. Then configure tlsCertPath in the cache-name entry within the ncache section of the client's appsettings.json and ensure that the required Root CAs are trusted.

When enabling Mutual TLS with Enable-NCacheTLS -UseMutualTls, you must provide -TlsCertPath for the machine running the cmdlet, including when it is an NCache server. Ensure that the client certificate is trusted on the machine running the cmdlet and that each target server trusts its issuing Root CA. If the client private key is encrypted, also provide -TlsCertPassword. Configure the client certificate separately in each client application.

To enable Mutual TLS with NCache-provided server certificates, run:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12" `
                 -TlsCertPath "C:\certs\admin-client.pem" -UseMutualTls

To enable Mutual TLS while using a custom server certificate, run:

Enable-NCacheTLS -Node "20.200.20.11,20.200.20.12" `
                 -CustomCertificatePath "C:\certs\ncache-chain.pem" `
                 -TlsCertPath "C:\certs\admin-client.pem" `
                 -UseMutualTls

This command runs from a machine without an NCache server installation and connects to an mTLS-protected node using a password-protected client PEM. The -CustomCertificate* parameters configure the server, while -TlsCert* authenticate this PowerShell connection.

Enable-NCacheTLS -Node "20.200.20.11" `
                 -CustomCertificatePath "C:\certs\server.pem" `
                 -CustomCertificatePassword "serverKeyPassword" `
                 -TlsCertPath "C:\certs\admin-client.pem" `
                 -TlsCertPassword "clientKeyPassword" -UseMutualTls

When running a TLS management cmdlet against a server already requiring Mutual TLS, specify -TlsCertPath and, if the client PEM private key is encrypted, -TlsCertPassword. These parameters authenticate the command-running machine; they are separate from -CustomCertificatePath and -CustomCertificatePassword, which configure the server certificate.

After you confirm the operation, Enable-NCacheTLS applies the configuration and performs the required restarts automatically. Review the progress and any reported errors. Restart the client application only if it needs to load newly added or changed Mutual TLS certificate settings, as described in Client Application Restarts.

Disable TLS Using PowerShell

Use the Disable-NCacheTLS cmdlet to disable TLS on the local NCache server or on one or more remote server nodes. If Mutual TLS is enabled on a target server, -TlsCertPath is required, including when disabling TLS on the local server. Supply -TlsCertPassword if the client private key is encrypted. To keep TLS enabled while disabling only Mutual TLS, run Enable-NCacheTLS without -UseMutualTls, providing -TlsCertPath to authenticate to the server that currently requires Mutual TLS. Include the intended server certificate and protocol settings when applying this configuration.

The cmdlet asks for confirmation before removing the TLS settings and performing the required restarts. Enter Y to continue, or N to cancel without changing the settings or restarting components. Use -Force to skip confirmation. If TLS is already disabled on a target node, that node is left unchanged and is not restarted.

To disable TLS on the local server, run:

Disable-NCacheTLS

To disable TLS on multiple remote nodes, run:

Disable-NCacheTLS -Node "20.200.20.11,20.200.20.12"

If NCache security is enabled on the remote nodes, provide the required credentials:

Disable-NCacheTLS -Node "20.200.20.11,20.200.20.12" -Credentials (Get-Credential)

This command disables TLS when the target nodes require Mutual TLS. The client certificate is required whether or not the machine running the cmdlet has an NCache server installation. The client PEM contains a password-protected private key.

Disable-NCacheTLS -Node "20.200.20.11,20.200.20.12" `
                  -TlsCertPath "C:\certs\client.pem" `
                  -TlsCertPassword "clientKeyPassword"

Disabling TLS does not necessarily delete previously generated certificate files, so an existing leaf.pem can remain on the server after TLS has been disabled. For complete syntax and parameter details, refer to Disable-NCacheTLS.

TLS Configuration File

NCache stores the TLS configuration in the tls.ncconf file located at:

  • Windows: %NCHOME%\config\tls.ncconf
  • Linux: /opt/ncache/config/tls.ncconf

The tls.ncconf file specifies whether TLS and Mutual TLS are enabled, the path of a custom certificate and its private-key password when applicable, and the TLS protocol version. For example, when TLS is enabled using an NCache-provided certificate without Mutual TLS, the configuration appears as follows:

<tls-info>
    <enable>true</enable>
    <use-mutual-tls>false</use-mutual-tls>
    <custom-certificate-path></custom-certificate-path>
    <protocol-version>tls12</protocol-version>
    <password></password>
</tls-info>

The elements in the configuration specify the following:

  • <enable> specifies whether TLS is enabled.
  • <use-mutual-tls> specifies whether connecting clients are required to present a certificate for Mutual TLS.
  • <custom-certificate-path> specifies the absolute path of the custom PEM certificate. This element remains empty when an NCache-provided certificate is used.
  • <protocol-version> specifies the TLS protocol version. Supported values are tls12 for TLS 1.2, tls13 for TLS 1.3, and auto to negotiate the highest mutually supported TLS version.
  • <password> specifies the password for the private key in a custom PEM certificate when that key is password-protected. Leave this element empty when no password is required.

When a custom certificate is used, custom-certificate-path contains the absolute path of the PEM file. Set <password> only if its private key is password-protected. The following example uses an encrypted key:

<tls-info>
    <enable>true</enable>
    <use-mutual-tls>false</use-mutual-tls>
    <custom-certificate-path>C:\certs\ncache-chain.pem</custom-certificate-path>
    <password>your-server-key-password</password>
    <protocol-version>tls12</protocol-version>
</tls-info>

When Mutual TLS is enabled, use-mutual-tls is set to true:

<tls-info>
    <enable>true</enable>
    <use-mutual-tls>true</use-mutual-tls>
    <custom-certificate-path></custom-certificate-path>
    <protocol-version>tls12</protocol-version>
    <password></password>
</tls-info>

When TLS is disabled, enable is set to false:

<tls-info>
    <enable>false</enable>
    <use-mutual-tls>false</use-mutual-tls>
    <custom-certificate-path></custom-certificate-path>
    <protocol-version></protocol-version>
    <password></password>
</tls-info>

For complete configuration tag descriptions, see TLS Config (tls.ncconf).

Verify TLS Connectivity

After applying TLS and restarting the processes that require a restart, verify that an NCache client can connect to the cache successfully. You can use the Test-Stress PowerShell cmdlet against a running cache to verify client connectivity.

Test-Stress -CacheName defaultCache

If Mutual TLS is enabled, make sure the client certificate is configured in the application, the certificate file is accessible to the application account, and the required Root CAs are trusted before verifying connectivity. A failed connection at this stage commonly indicates an incorrect certificate path, certificate trust issue, or a process that has not yet been restarted with the updated TLS configuration.

Troubleshooting

If TLS connectivity fails, verify the configuration systematically. The current TLS model depends on valid PEM files, certificate trust, correct server and client configuration, and connectivity to the NCache certificate-signing service when NCache-provided certificates are used.

  • Confirm that every participating server node was added to the TLS configuration and received the intended settings.
  • For NCache-provided certificates, verify that the server can reach the NCache certificate-signing service and that the NCache license information required for certificate signing is valid.
  • Verify that leaf.pem exists on each server node after NCache-provided TLS is enabled and that the relevant NCache process can access the file.
  • For custom certificates, verify that the configured PEM path exists on every selected server node and that the PEM contains the private key, leaf certificate, and Intermediate certificates in the required order.
  • Ensure that the corresponding Root CA certificate is installed in the operating system's trust store or placed in the same directory as the custom certificate.
  • If the custom server certificate uses an encrypted private key, verify that the password element in tls.ncconf matches the key password.
  • If Mutual TLS is enabled, verify that every connecting client has a valid client certificate, that tlsCertPath points to the correct PEM file for modern .NET or PFX file for .NET Framework, and that the application account can access the file and its private key.
  • Verify that the server trusts the client certificate's issuing Root CA and that the client trusts the server certificate's issuing Root CA.
  • Review the automatic restart results after enabling or changing TLS. If a step failed, manually restart the affected component. Stop any running client cache that still uses the previous settings, and check whether the client application needs to load updated Mutual TLS certificate settings. See Restart Behavior After TLS Configuration Changes.
  • If an NCache-provided certificate is not renewed successfully, verify connectivity to the signing service and review the relevant TLS logs for certificate renewal failures.

See Also

Enable-NCacheTLS
Disable-NCacheTLS
New-NCacheTlsCertificate
TLS Config (tls.ncconf)
Configure Security for Cache
Configure Encryption for Cache

Contact Us

PHONE

+1 214-619-2601   (US)

+44 20 7993 8327   (UK)

 
EMAIL

sales@alachisoft.com

support@alachisoft.com

NCache
  • Edition Comparison
  • NCache Architecture
  • Benchmarks
Try NCache
Pricing
NCache Playground

Deployments
  • Cloud
  • Docker
  • Kubernetes
  • On-Premises
Technical Use Cases
  • ASP.NET Sessions
  • ASP.NET Core Sessions
  • Pub/Sub Messaging
  • SignalR Backplane
  • Internet of Things (IoT)
  • NoSQL Database
  • Stream Processing
  • Microservices
Resources
  • Blogs
  • Foundations
  • Videos
  • Comparisons
  • Shows
  • Whitepapers
  • Articles
  • Tech Talks
  • Magazine Articles
  • Third-Party Articles
Customer Case Studies
  • Testimonials
  • Customers
Support
  • Docs
  • Schedule a Demo
  • Tips
Company
  • Leadership
  • Partners
  • News
  • Events
  • Careers
Contact Us

  • EnglishChinese (Simplified)FrenchGermanItalianJapaneseKoreanPortugueseSpanish

  • Terms of Use
  •  
  • Privacy Policy
  •  
  • Cookie Policy
© Copyright Alachisoft 2002 - . All rights reserved. NCache is a registered trademark of Diyatech Corp.
  • Facebook
  • Twitter
  • Youtube
  • LinkedIn
  • RSS