Connecting to a sharded Redis cluster

redis-cli \
    -c \
    -h <FQDN of master host in desired shard> \
    -a <password> \
    -p 6380 \
    --tls \
    --cacert ~/.redis/YandexCA.crt \

package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"github.com/go-redis/redis/v7"
	"io/ioutil"
	"net"
	"strings"
	"time"
)

func main() {
	caCert, err := ioutil.ReadFile("/home/<home directory>/.redis/YandexCA.crt")
	if err != nil {
		panic(err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)

	hostports := []string{
		"<FQDN of the master host in shard 1>:6380",
		...
		"<FQDN of the master host in shard N>:6380",
	}
	options := redis.UniversalOptions{
		Addrs:        hostports,
		MaxRedirects: 1,
		Password:     "<password>",
		DB:           0,
		ReadOnly:     false,
		DialTimeout:  5 * time.Second,
		TLSConfig: &tls.Config{
			RootCAs:            caCertPool,
			InsecureSkipVerify: true,
			VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
				certs := make([]*x509.Certificate, len(rawCerts))
				for i := 0; i < len(rawCerts); i++ {
					cert, err := x509.ParseCertificate(rawCerts[i])
					if err != nil {
						return fmt.Errorf("error parsing certificate: %+v", err)
					}
					certs[i] = cert
				}

				opts := x509.VerifyOptions{
					Roots:         caCertPool,
					CurrentTime:   time.Now(),
					DNSName:       "",
					Intermediates: x509.NewCertPool(),
				}

				for i := range certs {
					if i == 0 {
						continue
					}
					opts.Intermediates.AddCert(certs[i])
				}
				_, err := certs[0].Verify(opts)
				return err
			},
		},
	}
	options.Dialer = func(ctx context.Context, network, addr string) (net.Conn, error) {
		parts := strings.Split(addr, ":")
		newAddr := addr
		if len(parts) > 1 && !strings.HasPrefix(parts[0], "[") {
			newAddr = "[" + strings.Join(parts[:len(parts)-1], ":") + "]:" + parts[len(parts)-1]
		}

		netDialer := &net.Dialer{
			Timeout:   options.DialTimeout,
			KeepAlive: 5 * time.Minute,
		}
		return tls.DialWithDialer(netDialer, network, newAddr, options.TLSConfig)
	}
	client := redis.NewUniversalClient(&options)
	err = client.Set("foo", "bar", 0).Err()
	if err != nil {
		panic(err)
	}

	get := client.Get("foo")
	if get.Err() != nil {
		panic(err)
	}
	fmt.Println(get.String())
}

package com.example;

import redis.clients.jedis.DefaultJedisClientConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import javax.net.ssl.SSLParameters;
import java.util.HashSet;
import java.util.Set;

public class App {
  public static void main(String[] args) {
    System.setProperty("javax.net.ssl.trustStore", "/home/<home directory>/.redis/YATrustStore");
    System.setProperty("javax.net.ssl.trustStorePassword", "<password of secure certificate storage>");

    JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
    SSLParameters sslParameters = new SSLParameters();
    jedisClusterNodes.add(new HostAndPort("<FQDN of the master host in shard 1>", 6380));
    ...
    jedisClusterNodes.add(new HostAndPort("<FQDN of the master host in shard N>", 6380));

    DefaultJedisClientConfig jedisClientConfig = DefaultJedisClientConfig.builder().
            password("<cluster password>").
            ssl(true).
            sslParameters(sslParameters).
            build();

    try {
      JedisCluster jc = new JedisCluster(jedisClusterNodes, jedisClientConfig, 5, jedisPoolConfig);

      jc.set("foo", "bar");
      System.out.println(jc.get("foo"));
      jc.close();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
}

"use strict";

const Redis = require("ioredis");
const fs = require("fs");

const cluster = new Redis.Cluster(
    [
        {
            host: "<FQDN of the master host in shard 1>",
            port: 6380
        },
        ...
        {
            host: "<FQDN of the master host in shard N>",
            port: 6380
        },
    ],
    {
        redisOptions: {
            password: "<password>",
            tls: {
                ca: [fs.readFileSync("/home/<home directory>/.redis/YandexCA.crt")],
                checkServerIdentity: () => {
                    return null;
                }
            }
        }
    }
);

cluster.on("ready", () => {
    Promise.all([
        cluster.set("foo", "bar"),
        cluster.get("foo")
    ]).then(
        (result) => {
            console.log(result[1]); // result == [ "OK", "bar"]
            cluster.disconnect();
        },
        (reject) => {
             console.log(reject);
             cluster.disconnect();
        }
    );
});

 <?php

 require "Predis/Autoloader.php";
 Predis\Autoloader::register();

 $hosts = [
     'tls://<FQDN of the master host in shard 1>:6380?ssl[cafile]=/home/<home directory>/.redis/YandexCA.crt',
     ...
     'tls://<FQDN of the master host in shard N>:6380?ssl[cafile]=/home/<home directory>/.redis/YandexCA.crt',
 ];

 $options = [
     'cluster' => 'predis',
     'parameters' => [
         'password' => '<password>',
     ],
 ];

 $conn = new Predis\Client($hosts, $options);
 $conn->set('foo', 'bar');

 var_dump($conn->get("foo"));

 $conn->disconnect();
 ?>

import OpenSSL
from rediscluster import RedisCluster

startup_nodes = [
    {"host": "<FQDN of the master host in shard 1>", "port": 6380},
    ...
    {"host": "<FQDN of the master host in shard N>", "port": 6380},
]

rc = RedisCluster(
    startup_nodes=startup_nodes,
    decode_responses=True,
    skip_full_coverage_check=True,
    password="<password>",
    ssl=True,
    ssl_ca_certs="/home/<home directory>/.redis/YandexCA.crt",
)

rc.set("foo", "bar")

print(rc.get("foo"))

# coding: utf-8

require 'redis'

nodes = [
  { host: '<FQDN of the master host in shard 1>', port: 6380 },
  ...
  { host: '<FQDN of the master host in shard N>', port: 6380 }
]

conn = Redis.new(
  cluster: nodes,
  password: '<password>',
  ssl: true,
  ssl_params: {
    ca_file: '/home/<home directory>/.redis/YandexCA.crt',
    verify_hostname: false
  }
)

conn.set('foo', 'bar')
puts conn.get('foo')

conn.close