Configure TLS with Platform Operator

clc config add hz cluster.name=dev cluster.address=<EXTERNAL-IP> ssl.enabled=true ssl.server=example ssl.ca-path=<PATH/TO/example.crt>

package com.hazelcast;

import com.hazelcast.client.HazelcastClient;
import com.hazelcast.client.config.ClientConfig;
import com.hazelcast.config.SSLConfig;
import com.hazelcast.core.HazelcastInstance;

import java.util.Properties;

public class example {
  public static void main(String[] args) throws Exception {
    ClientConfig config = new ClientConfig();
    config.getNetworkConfig().addAddress("<EXTERNAL-IP>");

    Properties clientSSLProps = new Properties();
    clientSSLProps.setProperty("trustStore", "example.jks");
    clientSSLProps.setProperty("trustStorePassword", "hazelcast");
    config.getNetworkConfig().setSSLConfig(new SSLConfig()
      .setEnabled(true)
      .setProperties(clientSSLProps));

    HazelcastInstance client = HazelcastClient.newHazelcastClient(config);
    System.out.println("Successful connection!");
  }
}

'use strict';

const { Client } = require('hazelcast-client');

const clientConfig = {
  network: {
    clusterMembers: [
      '<EXTERNAL-IP>'
    ],
    ssl: {
      enabled: true,
      sslOptionsFactoryProperties: {
        caPath: 'example.crt',
        servername: 'example',
      }
    }
  }
};

(async () => {
  try {
    const client = await Client.newHazelcastClient(clientConfig);
    console.log('Successful connection!');
  } catch (err) {
    console.error('Error occurred:', err);
  }
})();

package main

import (
	"context"
	"crypto/tls"
	"fmt"

	"github.com/hazelcast/hazelcast-go-client"
	"github.com/hazelcast/hazelcast-go-client/cluster"
)

func main() {
	var clusterConfig cluster.Config
	clusterConfig.Network.SetAddresses("<EXTERNAL-IP>")
	clusterConfig.Discovery.UsePublicIP = true
	clusterConfig.Network.SSL.Enabled = true
	clusterConfig.Network.SSL.SetTLSConfig(&tls.Config{InsecureSkipVerify: true})

	ctx := context.Background()
	config := hazelcast.Config{Cluster: clusterConfig}
	client, err := hazelcast.StartNewClientWithConfig(ctx, config)
	if err != nil {
		panic(err)
	}
	fmt.Println("Successful connection!", client)
}

import logging

import hazelcast

logging.basicConfig(level=logging.INFO)

client = hazelcast.HazelcastClient(
    cluster_members=["<EXTERNAL-IP>"],
    use_public_ip=True,
    ssl_enabled=True,
    ssl_cafile="example.crt",
)

print("Successful connection!", flush=True)

clc -c hz map size

cd java
mvn package
java -jar target/*.jar

cd nodejs
npm install
npm start

cd go
go run example.go

cd python
pip install -r requirements.txt
python example.py