nc, err := nats.Connect("localhost",
	nats.Secure(),
	nats.RootCAs("resources/certs/ca.pem")) // May need this if server is using self-signed certificate
if err != nil {
	log.Fatal(err)
}
defer nc.Close()

// Do something with the connection

class SSLUtils2 {
    public static String KEYSTORE_PATH = "src/main/resources/keystore.jks";
    public static String TRUSTSTORE_PATH = "src/main/resources/cacerts";
    public static String STORE_PASSWORD = "password";
    public static String KEY_PASSWORD = "password";
    public static String ALGORITHM = "SunX509";

    public static KeyStore loadKeystore(String path) throws Exception {
        KeyStore store = KeyStore.getInstance("JKS");
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(path));

        try {
            store.load(in, STORE_PASSWORD.toCharArray());
        } finally {
            if (in != null) {
                in.close();
            }
        }

        return store;
    }

    public static KeyManager[] createTestKeyManagers() throws Exception {
        KeyStore store = loadKeystore(KEYSTORE_PATH);
        KeyManagerFactory factory = KeyManagerFactory.getInstance(ALGORITHM);
        factory.init(store, KEY_PASSWORD.toCharArray());
        return factory.getKeyManagers();
    }

    public static TrustManager[] createTestTrustManagers() throws Exception {
        KeyStore store = loadKeystore(TRUSTSTORE_PATH);
        TrustManagerFactory factory = TrustManagerFactory.getInstance(ALGORITHM);
        factory.init(store);
        return factory.getTrustManagers();
    }

    public static SSLContext createSSLContext() throws Exception {
        SSLContext ctx = SSLContext.getInstance(Options.DEFAULT_SSL_PROTOCOL);
        ctx.init(createTestKeyManagers(), createTestTrustManagers(), new SecureRandom());
        return ctx;
    }
}

public class ConnectTLSURL {
    public static void main(String[] args) {

        try {
            SSLContext.setDefault(SSLUtils2.createSSLContext()); // Set the default context
            Options options = new Options.Builder().
                                server("tls://localhost:4222"). // Use the TLS protocol
                                build();
            Connection nc = Nats.connect(options);
            
            // Do something with the connection

            nc.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

let nc = NATS.connect({
    url: "tls://demo.nats.io:4443",
    tls: true
});

import asyncio
import ssl
import certifi
from nats.aio.client import Client as NATS
from nats.aio.errors import ErrTimeout

async def run(loop):
    nc = NATS()

    # If using Python 3.7 in OS X and getting SSL errors, run first:
    #
    # /Applications/Python\ 3.7/Install\ Certificates.command
    #
    # Setting the tls as the scheme will use same defaults as `ssl.create_default_context()`
    #
    await nc.connect("tls://demo.nats.io:4443", loop=loop)

    async def message_handler(msg):
        subject = msg.subject
        reply = msg.reply
        data = msg.data.decode()
        print("Received a message on '{subject} {reply}': {data}".format(
            subject=subject, reply=reply, data=data))

    # Simple publisher and async subscriber via coroutine.
    sid = await nc.subscribe("foo", cb=message_handler)
    await nc.flush()

    # Stop receiving after 2 messages.
    await nc.auto_unsubscribe(sid, 2)
    await nc.publish("foo", b'Hello')
    await nc.publish("foo", b'World')
    await nc.publish("foo", b'!!!!!')
    await asyncio.sleep(1, loop=loop)
    await nc.close()

EM.run do

  # In order to use TLS with the Ruby NATS client, use the :tls option
  # when customizing the connection with an empty block.
  options = {
    :servers => [
      'nats://demo.nats.io:4443',
    ],
    :tls => {}
  }

  NATS.connect(options) do |nc|
    puts :connected
  end
end

// will throw an exception if connection fails
let nc = await connect({
    url: "tls://demo.nats.io:4443"
});

nc.close();