10 Client.md

title	excerpt
Client	Client is a Redis client to interact with a Redis server or cluster.

Client is a Redis client to interact with a Redis server or cluster. It exposes a promise-based API, which users can interact with in an asynchronous manner.

Though the API intends to be thorough and extensive, it does not expose the whole Redis API. Instead, the intent is to expose Redis for use cases most appropriate to k6.

Note that the Client is configured through the Options object.

Example

import { check } from 'k6';
import http from 'k6/http';
import redis from 'k6/experimental/redis';
import exec from 'k6/execution';
import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.2/index.js';

export const options = {
  scenarios: {
    redisPerformance: {
      executor: 'shared-iterations',
      vus: 10,
      iterations: 200,
      exec: 'measureRedisPerformance',
    },
    usingRedisData: {
      executor: 'shared-iterations',
      vus: 10,
      iterations: 200,
      exec: 'measureUsingRedisData',
    },
  },
};

// Get the redis instance(s) address and password from the environment
const redis_addrs = __ENV.REDIS_ADDRS || '';
const redis_password = __ENV.REDIS_PASSWORD || '';

// Instantiate a new redis client
const redisClient = new redis.Client({
  addrs: redis_addrs.split(',') || new Array('localhost:6379'), // in the form of 'host:port', separated by commas
  password: redis_password,
});

// Prepare an array of crocodile ids for later use
// in the context of the measureUsingRedisData function.
const crocodileIDs = new Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

export function measureRedisPerformance() {
  // VUs are executed in a parallel fashion,
  // thus, to ensure that parallel VUs are not
  // modifying the same key at the same time,
  // we use keys indexed by the VU id.
  const key = `foo-${exec.vu.idInTest}`;

  redisClient
    .set(`foo-${exec.vu.idInTest}`, 1)
    .then(() => redisClient.get(`foo-${exec.vu.idInTest}`))
    .then((value) => redisClient.incrBy(`foo-${exec.vu.idInTest}`, value))
    .then((_) => redisClient.del(`foo-${exec.vu.idInTest}`))
    .then((_) => redisClient.exists(`foo-${exec.vu.idInTest}`))
    .then((exists) => {
      if (exists !== 0) {
        throw new Error('foo should have been deleted');
      }
    });
}

export function setup() {
  redisClient.sadd('crocodile_ids', ...crocodileIDs);
}

export function measureUsingRedisData() {
  // Pick a random crocodile id from the dedicated redis set,
  // we have filled in setup().
  redisClient
    .srandmember('crocodile_ids')
    .then((randomID) => {
      const url = `https://test-api.k6.io/public/crocodiles/${randomID}`;
      const res = http.get(url);

      check(res, {
        'status is 200': (r) => r.status === 200,
        'content-type is application/json': (r) => r.headers['content-type'] === 'application/json',
      });

      return url;
    })
    .then((url) => redisClient.hincrby('k6_crocodile_fetched', url, 1));
}

export function teardown() {
  redisClient.del('crocodile_ids');
}

export function handleSummary(data) {
  redisClient
    .hgetall('k6_crocodile_fetched')
    .then((fetched) => Object.assign(data, { k6_crocodile_fetched: fetched }))
    .then((data) => redisClient.set(`k6_report_${Date.now()}`, JSON.stringify(data)))
    .then(() => redisClient.del('k6_crocodile_fetched'));

  return {
    stdout: textSummary(data, { indent: '  ', enableColors: true }),
  };
}

key/value methods

Method	Redis command	Description
Client.set(key, value, expiration)	SET	Set key to hold value, with a time to live equal to expiration.
Client.get(key)	GET	Get the value of key.
Client.getSet(key, value)	GETSET	Atomically sets key to value and returns the old value stored at key.
Client.del(keys)	DEL	Removes the specified keys.
Client.getDel(key)	GETDEL	Get the value of key and delete the key.
Client.exists(keys)	EXISTS	Returns the number of key arguments that exist.
Client.incr(key)	INCR	Increments the number stored at key by one.
Client.incrBy(key, increment)	INCRBY	Increments the number stored at key by increment.
Client.decr(key)	DECR	Decrements the number stored at key by one.
Client.decrBy(key, decrement)	DECRBY	Decrements the number stored at key by decrement.
Client.randomKey()	RANDOMKEY	Returns a random key's value.
Client.mget(keys)	MGET	Returns the values of all specified keys.
Client.expire(key, seconds)	EXPIRE	Sets a timeout on key, after which the key will automatically be deleted.
Client.ttl(key)	TTL	Returns the remaining time to live of a key that has a timeout.
Client.persist(key)	PERSIST	Removes the existing timeout on key.

List methods

Method	Redis command	Description
Client.lpush(key, values)	LPSUH	Inserts all the specified values at the head of the list stored at key.
Client.rpush(key, values)	RPUSH	Inserts all the specified values at the tail of the list stored at key.
Client.lpop(key)	LPOP	Removes and returns the first element of the list stored at key.
Client.rpop(key)	RPOP	Removes and returns the last element of the list stored at key.
Client.lrange(key, start, stop)	LRANGE	Returns the specified elements of the list stored at key.
Client.lindex(key, start, stop)	LINDEX	Returns the specified element of the list stored at key.
Client.lset(key, index, element)	LSET	Sets the list element at index to element.
Client.lrem(key, count, value)	LREM	Removes the first count occurrences of value from the list stored at key.
Client.llen(key)	LLEN	Returns the length of the list stored at key.

Hash methods

Method	Redis command	Description
Client.hset(key, field, value)	HSET	Sets the specified field in the hash stored at key to value.
Client.hsetnx(key, field, value)	HSETNX	Sets the specified field in the hash stored at key to value, only if field does not yet exist.
Client.hget(key, field)	HGET	Returns the value associated with field in the hash stored at key.
Client.hdel(key, fields)	HDEL	Deletes the specified fields from the hash stored at key.
Client.hgetall(key)	HGETALL	Returns all fields and values of the hash stored at key.
Client.hkeys(key)	HKEYS	Returns all fields of the hash stored at key.
Client.hvals(key)	HVALS	Returns all values of the hash stored at key.
Client.hlen(key)	HLEN	Returns the number of fields in the hash stored at key.
Client.hincrby(key, field, increment)	HINCRBY	Increments the integer value of field in the hash stored at key by increment.

Set methods

Method	Redis command	Description
Client.sadd(key, members)	SADD	Adds the specified members to the set stored at key.
Client.srem(key, members)	SREM	Removes the specified members from the set stored at key.
Client.sismember(key, member)	SISMEMBER	Returns if member is a member of the set stored at key.
Client.smembers(key)	SMEMBERS	Returns all the members of the set values stored at keys.
Client.srandmember(key)	SRANDMEMBER	Returns a random element from the set value stored at key.
Client.spop(key)	SPOP	Removes and returns a random element from the set value stored at key.

miscellaneous

Method	Description
Client.sendCommand(command, args)	Send a command to the Redis server.