Connecting to Your Cluster

<repositories>
    <repository>
        <id>GridGain External Repository</id>
        <url>https://www.gridgainsystems.com/nexus/content/repositories/external</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>org.gridgain</groupId>
        <artifactId>ignite-core</artifactId>
        <version>${gg.version}</version>
    </dependency>
</dependencies>

    public static void main(String[] args) {
        SslConfiguration sslConfiguration = new SslConfigurationBuilder()
                .enabled(true)
                .build();
        IgniteClientAuthenticator auth = BasicAuthenticator.builder()
                .username("{login}")
                .password("{password}")
                .build();
        // Connect to the cluster.
        try (IgniteClient client = IgniteClient.builder()
                .addresses("{connectionUri}:10800")
                .authenticator(auth)
                .ssl(sslConfiguration)
                .build()) {
        // Query the table using SQL.
            client.sql().execute(null, "CREATE TABLE IF NOT EXISTS Person (id VARCHAR PRIMARY KEY, name VARCHAR)");

        }
    }

#include <chrono>
#include <iostream>

#include "ignite/client/ignite_client.h"
#include <ignite/client/basic_authenticator.h>

using namespace ignite;
using namespace std::chrono_literals;

void main()
{
try {
auto auth = std::make_shared<basic_authenticator>("{login}", "{password}");
ignite_client_configuration cfg{"{connectionUri}:10800"};
cfg.set_authenticator(std::move(auth));
cfg.set_ssl_mode(ssl_mode::REQUIRE);

    // Connect to the cluster.
    auto client = ignite_client::start(std::move(cfg), 5s);
    auto sql = client.get_sql();

    // Query the table using SQL.
    sql.execute(nullptr, {"CREATE TABLE Person(ID INT PRIMARY KEY, VAL VARCHAR)"}, {});
  } catch (std::exception &e) {
    std::cout << e.what() << std::endl;
    return 1;
  }
}

pip install pygridgain>=9

import asyncio
import ssl
from pygridgain import AsyncClient, EndPoint, BasicAuthenticator, SSLConfig
async def main():
# Client configuration.
# Replace the {login} and {password} with your cluster credentials.
address = EndPoint("{connectionUri}", 10800)
auth = BasicAuthenticator(username="{login}", password="{password}")
ssl_cfg = SSLConfig(cert_reqs=ssl.CERT_NONE)
# Connect to the cluster.
async with AsyncClient(
    address,
    authenticator=auth,
    ssl_config=ssl_cfg,
) as client:
    # Get or create a BinaryMap (cache-like key/value structure).
    my_map = await client.structures().get_or_create_binary_map("MyTestMap")
    # Put/get example.
    await my_map.put(b"1", b"foo")
    result = await my_map.get(b"1")
    # Print the decoded result.
    print(result.decode("utf-8"))
    # Optional checks.
    exists = await my_map.contains(b"1")
    print("Key exists:", exists)

pip install pygridgain_dbapi

import pygridgain_dbapi
HOST = "{connectionUri}"
PORT = 10800
IDENTITY = "{login}"
SECRET = "{password}"
# SQL object name.
TABLE = "Person"
def connect():
return pygridgain_dbapi.connect(
address=f"{HOST}:{PORT}",
identity=IDENTITY,
secret=SECRET,
use_ssl=True,
)
def main():
# Connect to the cluster.
conn = connect()
try:
cur = conn.cursor()

    # Create table.
    cur.execute(
        f"CREATE TABLE IF NOT EXISTS {TABLE} ("
        f"  id INTEGER PRIMARY KEY, "
        f"  name VARCHAR"
        f")"
    )

    # Insert values into the table.
    cur.execute(
        f"INSERT INTO {TABLE}(id, name) VALUES "
        f"(1, 'Ed'), (2, 'Ann'), (3, 'Emma')"
    )
    # Count.
    cur.execute(f"SELECT COUNT(*) FROM {TABLE}")
    count = cur.fetchone()[0]
    print(f"COUNT(*) FROM {TABLE} = {count}")
    # Commit is recommended for DDL/DML in DB-API usage.
    conn.commit()
finally:
# Close the connection.
conn.close()