Connecting With Thin Clients

String thinClient = "13.57.50.182:9490"; // Provide actual thinClient address from the "Cluster Info" dialog.
String username = "ignite"; // This is a pre-defined username provided by GG Cloud.
String pwd = "myclusterpassword"; // Provide actual cluster password from the "Cluster Info" dialog.
String sslPwd = "LO4B0E0A3LtV7nwETnhY"; // Provide actual SSL password from the "Cluster Info" dialog.
String store = "/path/to/SSL/keyStore.jks"; // Provide the path where the file is stored after downloading from GG Cloud.

ClientConfiguration cfg = new ClientConfiguration()
        .setAddresses(thinClient)
        .setUserName(username)
        .setUserPassword(pwd)
        .setSslMode(SslMode.REQUIRED)
        .setSslClientCertificateKeyStorePath(store)
        .setSslClientCertificateKeyStoreType("JKS")
        .setSslClientCertificateKeyStorePassword(sslPwd)
        .setSslTrustCertificateKeyStorePath(store)
        .setSslTrustCertificateKeyStoreType("JKS")
        .setSslTrustCertificateKeyStorePassword(sslPwd)
        .setSslKeyAlgorithm("SunX509")
        .setSslTrustAll(false)
        .setSslProtocol(SslProtocol.TLS);

try (IgniteClient igniteClient = Ignition.startClient(cfg)) {
    final String CACHE_NAME = "put-get-example";

    ClientCache<Integer, String> cache = igniteClient.getOrCreateCache(CACHE_NAME);

    System.out.format(">>> Created cache [%s].\n", CACHE_NAME);

    Integer key = 1;
    String val = "Hello";

    cache.put(key, val);

    System.out.format(">>> Saved [%s] in the cache.\n", val);

    String cachedVal = cache.get(key);

    System.out.format(">>> Loaded [%s] from the cache.\n", cachedVal);
}
catch (Exception e) {
    System.err.format("Unexpected failure: %s\n", e);

    e.printStackTrace();
}

IgniteClientConfiguration cfg = new IgniteClientConfiguration()
{
    Host = "18.144.56.147", // Provide actual thin client host address from the "Cluster Info" dialog.
    Port = 9790, // Provide actual thin client port from the "Cluster Info" dialog.
    Username = "ignite", // This is a pre-defined username provided by GG Cloud.
    Password = "myclusterpassword", // Provide actual cluster password from the "Cluster Info" dialog.

    SslStreamFactory = new SslStreamFactory
    {
        CertificatePath = @"C:\path\to\client.pfx", // Provide the path where the file is stored after downloading from GG Cloud.
        CertificatePassword = "jb5GtvpSfWVjQZ84T1ud", // Provide actual SSL password from the "Cluster Info" dialog.
        SkipServerCertificateValidation = true
    }
};

using (var cli = Ignition.StartClient(cfg))
{
    ICacheClient<Int32, String> cache = cli.GetOrCreateCache<Int32, String>("myCache");

    Console.WriteLine(">>> Created cache");

    cache.Put(1, "Hello");

    Console.WriteLine(">>> Saved value to cache");

    String val = cache.Get(1);

    Console.WriteLine(">>> Loaded value from cache: " + val);

    cli.DestroyCache("myCache");
}

int main()
{
    using namespace ignite::thin;
    using namespace boost::chrono;

    IgniteClientConfiguration cfg;
    cfg.SetEndPoints("[CONNECTION_STRING]");
    cfg.SetSslMode(SslMode::REQUIRE);
    cfg.SetSslCertFile("/path/to/SSL/client.pem"); // Provide the path where the file is stored after downloading from GG Cloud.
    cfg.SetSslCaFile("/path/to/SSL/client.pem");
    cfg.SetSslKeyFile("/path/to/SSL/client.pem");
    cfg.SetUser("ignite"); // This is a pre-defined username provided by GG Cloud.
    cfg.SetPassword("myclusterpassword"); // Provide actual cluster password from the "Cluster Info" dialog.

    int retcode = 0;

    try
    {
        IgniteClient client = IgniteClient::Start(cfg);
        cache::CacheClient<int32_t, int32_t> intCache = client.GetOrCreateCache<int32_t, int32_t>("test");

        intCache.Put(1, 1);

    }
    catch (const ignite::IgniteError& err)
    {
        std::cout << err.GetText() << std::endl;

        retcode = err.GetCode();
    }
    catch (const std::exception& err)
    {
        std::cout << err.what() << std::endl;

        retcode = -1;
    }

    std::cout << std::endl;
    std::cout << std::endl;

    return retcode;
}

from pyignite import Client

client = Client(
    username='ignite', # This is a pre-defined username provided by GG Cloud.
    Password = "myclusterpassword", # Provide actual cluster password from the "Cluster Info" dialog.
    use_ssl=True,
    ssl_keyfile='/path/to/SSL/client.pem', # Provide the path where the file is stored after downloading from GG Cloud.
    ssl_certfile='/path/to/SSL/client.pem'
)
client.connect('13.57.50.182', 9490) # Provide actual thinClient address from the "Cluster Info" dialog.

my_cache = client.create_cache('myCache')

my_cache.put('my key', 42)

result = my_cache.get('my key')
print(result)

<?php

require_once '/src/vendor/autoload.php';

use Apache\Ignite\Client;
use Apache\Ignite\ClientConfiguration;

class PhpBench
{
    public function start(): void
    {
        $client = new Client();
        $client->connect(new ClientConfiguration("CONNECTION_STRING"));
        $tlsOptions = [
            'local_cert' => '/path/to/SSL/client.pem', // Provide the path where the file is stored after downloading from GG Cloud.
            'cafile' => '/path/to/SSL/client.pem',
            'verify_peer' => false, // This is a workaround; shouldn't be used in production
            'verify_peer_name' => false // This is a workaround; shouldn't be used in production
        ];
        $config = (new ClientConfiguration("CONNECTION_STRING"))
                ->setUserName("ignite") // This is a pre-defined username provided by GG Cloud.
                ->setPassword("myclusterpassword") // Provide actual cluster password from the "Cluster Info" dialog.
                ->setTLSOptions($tlsOptions);

        $client->connect($config);
        $cache = $client->getOrCreateCache("myCache");
        $cache->put(1, 1);
    }
}

(new PhpBench())->start();

const FS = require('fs');

IgniteClient = require('apache-ignite-client');
IgniteClientConfiguration = IgniteClient.IgniteClientConfiguration;

igniteClient = new IgniteClient();

async function start() {
   const connectionOptions = {
       'cert' : FS.readFileSync('/path/to/SSL/client.pem'),
       'ca' : FS.readFileSync('/path/to/SSL/client.pem'),
       'key' : FS.readFileSync('/path/to/SSL/client.pem'),
       'rejectUnauthorized': false
    };

    await igniteClient.connect(new IgniteClientConfiguration("[CONNECTION_STRING]")
        .setUserName("ignite") // This is a pre-defined username provided by GG Cloud.
        .setPassword("myclusterpassword") // Provide actual cluster password from the "Cluster Info" dialog.
        .setConnectionOptions(true, connectionOptions));
    setTimeout(run, 7);
}

async function run() {
    cache = await igniteClient.getOrCreateCache("test");
    await cache.put(1, 1);
}
start();