Redis

sudo apt install redis-server
sudo vim /etc/redis/redis.conf

Redis Config

# If you run Redis from upstart or systemd, Redis can interact with your
# supervision tree. Options:
#   supervised no      - no supervision interaction
#   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
#   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
#   supervised auto    - detect upstart or systemd method based on
#                        UPSTART_JOB or NOTIFY_SOCKET environment variables
# Note: these supervision methods only signal "process is ready."
#       They do not enable continuous liveness pings back to your supervisor.
supervised systemd

sudo mkdir /var/run/redis
sudo chown -R redis:redis /var/run/redis
sudo systemctl restart redis-server
sudo systemctl status  redis-server

###################<OR>###################
sudo vim /etc/systemd/system/redis.service

[Service]
Type=forking
ExecStart=/usr/bin/redis-server /etc/redis/redis.conf
ExecStop=/bin/kill -s TERM $MAINPID
ExecStartPost=/bin/sh -c "echo $MAINPID > /var/run/redis/redis.pid"
PIDFile=/run/redis/redis-server.pid

sudo systemctl daemon-reload
sudo systemctl restart redis-server
sudo systemctl status  redis-server

Commander

# docker-compose.yml
version: "3.9"
services:
  redis:
    image: redis:latest
    container_name: redis
    ports:
      - 127.20.22.10:6379:6379
    networks:
      redis:
        aliases:
          - redis.dev.chorke.org
  redis-commander:
    image: rediscommander/redis-commander:latest
    container_name: redis-commander
    depends_on:
      - redis
    environment:
      - REDIS_HOSTS=redis:redis
    ports:
      - 127.20.22.10:8081:8081
    networks:
      redis:
        aliases:
          - cli.redis.dev.chorke.org
networks:
  redis:
    name: redis

Pubsub

redis-cli SUBSCRIBE pubsub:queue :' Reading messages... (press Ctrl-C to quit) 1) "subscribe" 2) "pubsub:queue" 3) (integer) 1 1) "message" 2) "pubsub:queue" 3) "Hello" '

redis-cli PUBLISH pubsub:queue Hello

Expiry Key

redis-cli
:'
SET expiryNameKey Academia
EXPIRE expiryNameKey 5
GET expiryNameKey

EXPIREAT expiryNameKey 1665396610
TTL expiryNameKey

PERSIST expiryNameKey
TTL expiryNameKey
'

Spring Data Redis

package org.chorke.academia.beans.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component
public class ExpireKeyImpl {
    private static final Logger LOG = LoggerFactory.getLogger(ExpireKeyImpl.class);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private String hashKey = new UUID(new Date().getTime(), 0).toString();
    private String key = "name";

    @Scheduled(fixedRate = 20000)
    public void expireKeyValueWrite() {
        String value = "CoverPlus";
        redisTemplate.opsForHash().put(key, hashKey, value);
        redisTemplate.expire(key, 15, TimeUnit.SECONDS);
        LOG.info("Expiry-> PUT: Key: {}, Hash: {} Value: {}", key, hashKey, value);
    }

    @Scheduled(fixedRate = 5000)
    public void expiryKeyValueRead() {
        Object value = redisTemplate.opsForHash().get(key, hashKey);
        LOG.info("Expiry-> GET: Key: {}, Hash: {} Value: {}", key, hashKey, value);
    }
}

Reactive

---

package org.chorke.academia.beans.redis;

import org.chorke.academia.dto.SiteQueryDto;
import org.chorke.academia.utility.UUIDUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.time.Duration;

@Component
public class ReactiveExpireKeyImpl {
    private static final Logger LOG = LoggerFactory.getLogger(ReactiveExpireKeyImpl.class);

    @Autowired
    private ReactiveRedisTemplate<String, Object> reactiveRedisTemplate;

    private SiteQueryDto siteQueryDto;
    private String hashKey;
    private String key;

    @PostConstruct
    private void init() {
        siteQueryDto = SiteQueryDto.builder().code("1000").name("Academia").url("https://chorke.org/academia").build();
        hashKey = UUIDUtil.uuid().toString();
        key = "name";
    }

    @Scheduled(fixedRate = 20000)
    public void expireKeyValueWrite() {
        reactiveRedisTemplate.opsForHash().put(key, hashKey, siteQueryDto);
        reactiveRedisTemplate.expire(key, Duration.ofSeconds(15));
        LOG.info("Expiry-> PUT: Key: {}, Hash: {} Value: {}", key, hashKey, siteQueryDto);
    }

    @Scheduled(fixedRate = 5000)
    public void expiryKeyValueRead() {
        Mono<Object> value = reactiveRedisTemplate.opsForHash().get(key, hashKey);
        LOG.info("Expiry-> GET: Key: {}, Hash: {} Value: {}", key, hashKey, value.block());
    }
}

References

Docker Compose Ubuntu/GraalVM Minikube Quarkus Docker Fedora Maven Java Ant Ivy	Event-Driven Architecture With Redis Streams Redis PubSub with Spring Data Redis SSH Sessions Prevent From Freezing Redis MQ Implement with C# Redis Cache Configuration Redis Client Side Caching Redis Data Types Tutorial Redis Data Types Redis Pub/Sub Redis CLI	High availability with Redis Sentinel Redis Keyspace Notifications Scaling with Redis Cluster Redis Programmability Redis Transactions Redis Key Eviction Redis persistence Redis Pipelining Redis Streams Redis security
Spring Data Redis Messaging (Pub/Sub) Redis how to store values as JSON Spring Data Redis Reactive Redis Set Expiry on Key Troubleshooting Redis Redis Administration Epoch Converter