Before You Begin

Please complete the following operations according to the deployment location of the client program:

eSurfing Cloud ECS (recommended): Make sure that the CT-ECS instance and the Redis instance are in the same VPC.
Local server

DCS Redis instances only provide an intranet connection address by default. When accessing it over the Internet, you need to manually apply for an Internet connection address. For detailed operations, see Purchasing an EIP;

Depending on the network environment or operating system, the method of obtaining the public IP address of a local device may be different. The following is the reference method for different systems to obtain the public IP address of the local device through commands:

a. Linux: Open the terminal, enter the curl ifconfig.me command and press Enter.

b. Windows: Open the command prompt, enter the curl ip.me command and press Enter.

c. macOS: Open the terminal, enter the curl ifconfig.me command and press Enter. Note: If your Redis instance has a cluster architecture, the instance will provide the connection address of the proxy node by default, and the connection password is “ instance name # instance password “.

How to Obtain Connection Information

When using a client program to access a Redis instance, you usually need to obtain the following information and set it in the code:

Needed Information	Method of Obtaining
Connection address of the instance.	Redis instances support multiple connection addresses. It is recommended to use a private network connection for higher security and lower network latency. For more information, seeViewing the Connection Address.
The account of the instance (some client programs do not need this).	For cluster version instances, you can create a new account and grant different permissions. For more information, seeCreating and Managing an Account.
Password for the selected instance account.	Depending on the selected account, the password format is different:● Default account (account named after the instance name): Just fill in the password directly.● Newly created account: The password format is“user”#”password”. For example, the custom account is testaccount, and the password is Phdjeg@67534, and then the password should be testaccount#Phdjeg@67534.Note:● If you are accessing a Redis instance through a third-party database management tool, please enter user#password as the password.● If you forget your password, you can reset it. For detailed operations, seeResetting the Cache Instance Password.

Examples for Common Clients

For the clients supported by Redis, see the official Redis documentation. The following are connection examples for some clients.

Java

You can access Redis through the Jedis client. Jedis is an open-source client library based on Java programming language to interact with a Redis server. It allows Java applications to communicate with Redis servers over networks and perform various operations, such as data reading/writing, transaction processing, subscription publishing, etc. It provides simple and easy-to-use APIs, facilitating interactions with Redis servers. The steps to access Redis with Jedis are as follows:

Download and install the Jedis client.
Choose a connection method based on your business needs.

Open the Eclipse client, create a Project and configure a pom file. The specific contents are as follows:

<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>Latest version</version>
   <type>jar</type>
   <scope>compile</scope>
</dependency>

Based on the Jedis client version, enter the following code in the Project, and then modify the code according to the comment prompts.

JedisPoolConfig config = new JedisPoolConfig();
// Maximum number of idle connections allowed. No more than the maximum number of connections of the Redis instance.
config.setMaxIdle(200);
// Maximum number of idle connections allowed. Must be more than the maximum number of connections of the Redis instance.
config.setMaxTotal(300);
config.setTestOnBorrow(false);
config.setTestOnReturn(false);
// Replace the ip and password values with the connection address and password of the instance respectively.
String ip = "172.98.63.45";
String password = "testaccount#Phdjeg@67534";
JedisPool pool = new JedisPool(config, ip, 33016, 3000, password);
Jedis jedis = null;
try {
    jedis = pool.getResource();
    // Perform relevant operations. Example as follows.
    // Store & Retrieve a simple string
    jedis.set("foo", "bar");
    System.out.println(jedis.get("foo")); // prints bar

    // Store & Retrieve a HashMap
    Map<String, String> hash = new HashMap<>();;
    hash.put("name", "John");
    hash.put("surname", "Smith");
    hash.put("company", "Redis");
    hash.put("age", "29");
    jedis.hset("user-session:123", hash);
    System.out.println(jedis.hgetAll("user-session:123"));
    // Prints: {name=John, surname=Smith, company=Redis, age=29}
    }catch (Exception e) {
    // Timeour or other exceptions.
    e.printStackTrace();
}finally {
    if (jedis != null) {
        jedis.close();
    }
}

Pool.destroy();    // Call this method to destroy resources after exiting the application.This method will disconnect the instance and release resources.

Run the above code and the following results will be output on the Eclipse console, which means you have successfully connected to the DCCS Redis database.

bar
{name=John, surname=Smith, company=Redis, age=29}

Python

The steps to access Redis with Python are as follows:

Download and install the redis-py client.
Enter the following code in the Python editor, and then modify the code according to the comment prompts.

The Python version in this example is 3.9 and the redis-py version is 4.4.1.

#!/usr/bin/env python
#-*- coding: utf-8 -*-
import redis
// Replace the host and port values with the connection address and port number of the instance respectively.
host = '172.98.63.45'
port = 33016
// Replace the pwd value with the password of the instance.
pwd = 'testaccount#Phdjeg@67534'
r = redis.Redis(host=host, port=port, password=pwd)
# You can execute operations on databases after establishing a connection. The following code provides an example of using SET and GET methods.
r.set('foo', 'bar')
# True
print(r.get('foo'))
# bar
r.hset(‘user-session:123’, mapping={
    'name': 'John',
    "surname": 'Smith',
    "company": 'Redis',
    "age": 29
})
# True
r.hgetall('user-session:123')
# {'surname': 'Smith', 'name': 'John', 'company': 'Redis', 'age': '29'}

Run the above code and the following results will be output on the \ console, which means you have successfully connected to the DCCS Redis database.

bar
{'surname': 'Smith', 'name': 'John', 'company': 'Redis', 'age': '29'}

C or C++

The steps to access Redis with C or C++ clients are as follows:

Download and install the C Client.
Enter the following code in the C or C++ editor, and then modify the code according to the comment prompts.

The HiRedis version in this example is 1.1.0

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <hiredis.h>
int main(int argc, char **argv) {
    unsigned int j;
     redisContext *conn;
     redisReply *reply;
     if (argc < 3) {
             printf(“Usage: example {instance_ip_address} 33016 {password}\n”);
             exit(0);
     }
     const char *hostname = argv[1];
     const int port = atoi(argv[2]);
     const char *password = argv[3];
     struct timeval timeout = { 1, 500000 }; // 1.5 seconds
     conn = redisConnectWithTimeout(hostname, port, timeout);
     if (conn == NULL || conn->err) {
		if (conn) {
             printf(“Connection error: %s\n”, conn->errstr);
             redisFree(conn);
		} else {
             printf(“Connection error: can’t allocate redis context\n”);
		}
     exit(1);
     }
     /* AUTH */
     reply = redisCommand(conn, "AUTH %s", password);
     printf(“AUTH: %s\n”, reply->str);
     freeReplyObject(reply);

     /* Set */
     reply = redisCommand(conn,"SET %s %s", "welcome", "Hello, DCS for Redis!");
     printf(“SET: %s\n”, reply->str);
     freeReplyObject(reply);

     /* Get */
     reply = redisCommand(conn,"GET welcome");
     printf(“GET welcome: %s\n”, reply->str);
     freeReplyObject(reply);

Lettuce Redis Client with Spring Boot Integrated

The steps to access Redis with Spring Boot-integrated Lettuce are as follows:

Add dependencies: Add the dependencies of the Lettuce Redis client in the pom.xml file of the Spring Boot project.

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>VERSION</version>
</dependency>

Replace VERSION with the actual Lettuce Redis version number.

Configure connection information: Configure Redis connection information in the configuration file of the Spring Boot project.

spring.redis.host=your_redis_host

spring.redis.port=your_redis_port

spring.redis.password=your_redis_password (if a password has been set)

Replace your_redis_host with the host name of the Redis server and your_redis_port with the port number of the Redis server. If the Redis server has been set with a password, you need to set spring.redis.password.

Create a RedisTemplate Bean: Create a RedisTemplate Bean in the configuration class of the Spring Boot project, and configure the Lettuce Redis ConnectionFactory.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

Inject RedisTemplate: In the class that needs to use Redis, use the Redis functions by injecting the RedisTemplate Bean.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

Node.js Redis Client

The steps to access Redis with the Node.js Redis client are as follows:

Install dependencies: In the Node.js project, you first need to install the node_redis module. It can be installed via the npm command:

npm install redis

Import the module: In the code file that needs to be connected to Redis, use the required method to import the node_redis module.

const redis = require('redis');

Create a Redis client instance: Create a Redis client instance by calling the redis.createClient() method.

const client = redis.createClient();

This will create a Redis client instance with the default configurations to access the local Redis server (default port is 6379).

If you need to specify the host name and port number of the Redis server, you can pass the corresponding parameters using the createClient() method:

const client = redis.createClient({
  host: 'localhost',
  port: 6379
});

Perform Redis operations: By calling the method of the Redis client instance, you can perform various Redis operations. Here are some common example operations:

Setting key-value pairs:

client.set(‘key’, ‘value’, (err, result) => {
  if (err) {
    console.error(err);
  } else {
    console.log('Key-value pair has been set successfully');
  }
});

Obtaining key-value pairs:

client.get(‘key’, (err, result) => {
  if (err) {
    console.error(err);
  } else {
    console.log('Value:', result);
  }
});

Other types of Redis operations can be performed according to specific needs, such as hash table operations, list operations, set operations, etc.

Processing connection exceptions: When using the Redis client, you need to pay attention to processing connection exceptions. You can capture connection errors and network errors by listening to the error event, and then fix them appropriately.

client.on(‘error’, (err) => {
  console.error('Redis connection error:', err);
});

Close the connection: After using the Redis client, you should close the connection with the Redis server and release resources.

client.quit((err) => {
  if (err) {
    console.error('Error while quitting Redis connection:', err);
  } else {
    console.log('Redis connection has been closed');
  }
});

The connection can be closed by calling the quit() method, and the results of closing the connection are processed in the callback function.

The above are the basic steps to access Redis using the node_redis client in Node.js.According to actual needs, the above sample code can be extended and customized.

PHP Redis Client

The steps to access Redis using PHP client are as follows:

Install the extension: First, you need to install the phpredis extension. It can be installed via:

PECL (the PECL tool needs to be installed first):

pecl install redis

Manual compilation and installation:
Download the phpredis source code, decompress the source code, and go to the decompressed directory. Execute the following commands for compilation and installation:

phpize
./configure
make
sudo make install

After the installation is complete, you need to enable the phpredis extension in the PHP configuration file (such as php.ini). Add the following lines to the configuration file:

extension=redis.so

Create a Redis client instance: In the PHP file that needs to be connected to Redis, use the Redis class to create a Redis client instance.

$client = new Redis();

Connect to the Redis server: Connect to the Redis server by calling the connect() method. You can specify the host name and port number of the Redis server according to the actual situation.

$client->connect('127.0.0.1', 6379);

Perform Redis operations: By calling the method of the Redis client instance, you can perform various Redis operations. Here are some common example operations:

Setting key-value pairs:

$client->set('key', 'value');

Obtaining key-value pairs:

$value = $client->get('key');

By executing the command, you can perform other types of Redis operations according to specific needs, such as hash table operations, list operations, set operations, etc.

$result = $client->rawCommand('INFO');

Processing connection exceptions: When using the Redis client, you need to pay attention to processing connection exceptions. You can use the exception handling mechanisms to catch connection errors and network errors to handle them appropriately.

try {
  // Perform Redis operations
} catch (RedisException $e) {
  echo 'Redis connection error: ' . $e->getMessage();
}

Close the connection: After using the Redis client, you should close the connection with the Redis server and release resources.

$client->close();

The above are the basic steps to access Redis using the phpredis extension in PHP. According to actual needs, the above sample code can be extended and customized. Please ensure that the phpredis extension is correctly installed and enabled, and that you handle connection exceptions and close connections appropriately in your code.

Go Redis Client

The steps to access Redis using the Go client are as follows:

Install dependencies: Before using go-redis, you need to install the official Redis client library. Open the terminal and execute the following command to install the go-redis package:

go get github.com/go-redis/redis/v8

Import the dependency package: Import the go-redis package in the Go code to use the functions and types in it.

import "github.com/go-redis/redis/v8"

Create a Redis client instance: Use the redis.NewClient function to create a Redis client instance. Based on the actual situation, modify the Addr field to the host name and port number of the Redis server. If the Redis server has a password, you can specify the password in the Password field.

client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: “”, // If there is a password, enter the password
    DB:       0,  // Select database. The default is 0
})

Test connection: Use the client.Ping() function to test whether the connection to the Redis server is successful.

pong, err := client.Ping(context.Background()).Result()
if err != nil {
    fmt.Println("Redis connection error:", err)
    return
}
fmt.Println("Redis ping response:", pong)

Perform Redis operations: By calling the method of the Redis client instance, you can perform various Redis operations. Here are some common example operations:

Setting key-value pairs:

err := client.Set(context.Background(), "key", "value", 0).Err()
if err != nil {
    fmt.Println("Set error:", err)
}

Obtaining key-value pairs:

value, err := client.Get(context.Background(), "key").Result()
if err != nil {
    fmt.Println("Get error:", err)
} else {
    fmt.Println("Value:", value)
}

Execute command:

result, err := client.Do(context.Background(), "INFO").Result()
if err != nil {
    fmt.Println("Command error:", err)
} else {
    fmt.Println("Command result:", result)
}

Other types of Redis operations can be performed according to specific needs, such as hash table operations, list operations, set operations, etc.

Close the connection: After using the Redis client, you should close the connection with the Redis server and release resources.

err := client.Close()
if err != nil {
    fmt.Println("Error closing connection:", err)
}

DCS Redis Help Documentation

Accessing on Clients