Answering my own question, turns out there's no need to run lua script:

If using non-reactive Redis connection:

RedisConnection conn = null;
try {
    conn = connectionFactory.getConnection();
    conn.setConfig("notify-keyspace-events", "Ex");
} finally {
    if (conn != null) {
        conn.close();
    }
}

If using reactive Redis connection:

ReactiveRedisConnection conn = connectionFactory.getReactiveConnection();
        conn
                .serverCommands()
                .setConfig("notify-keyspace-events", "Ex")
                .filter(status -> status.equals("OK"))
                .doFinally(unused -> conn.close())
                .block(Duration.ofSeconds(5L));

At first, need to enable keyspace notification for expire event in redis. By default keyspace events notifications are disabled because while not very sensible the feature uses some CPU power. Notifications are enabled using the notify-keyspace-events of redis.conf or via the CONFIG SET.

notify-keyspace-events "Ex"

When you are done with redis, you need to configure your message listener with a pattern topic "__keyevent@*__:expired". Here goes the code sample.

Listener Class:

@Component
public class ExpirationListener implements MessageListener {
    private static final Logger logger = LoggerFactory.getLogger(ExpirationListener.class);

    @Override
    public void onMessage(Message message, byte[] bytes) {
        String key = new String(message.getBody());
        logger.debug("expired key: {}", key);
    }
}

Configuration:

@Bean
RedisMessageListenerContainer keyExpirationListenerContainer(RedisConnectionFactory connectionFactory, ExpirationListener expirationListener) {
    RedisMessageListenerContainer listenerContainer = new RedisMessageListenerContainer();
    listenerContainer.setConnectionFactory(connectionFactory);
    listenerContainer.addMessageListener(expirationListener, new PatternTopic("__keyevent@*__:expired"));
    listenerContainer.setErrorHandler(e -> logger.error("There was an error in redis key expiration listener container", e));
    return listenerContainer;
}

If you have this issue:

io.lettuce.core.RedisCommandExecutionException: ERR Unsupported CONFIG parameter: notify-keyspace-events

then add following configuration class in your application:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.ConfigureRedisAction;

@Configuration
public class RedisConfigureAction {
    @Bean
    public ConfigureRedisAction configureRedisAction() {
        return ConfigureRedisAction.NO_OP;
    }
}

As you mentioned, this is the standard behavior of Redis Keyspace notifications.

If a key expires while the application is down, the expiry event cannot be processed, there is no way to delay the notification.

In the context of session expiration in Spring Session Data Redis, this means that the SessionExpiredEvent/SessionDeletedEvent will not fire if the application is down (crashed etc) when the Redis Keyspace notification is sent.
This will cause problems if you have a task dependent on these events.
It also means that resources may not get cleaned up properly.

However, from a security standpoint, the session will still expire correctly and the user will not be able to continue using the expired session.

If an application is performing a critical task on expiry, a different data store may be a better fit, given the "fire and forget" nature of Redis Pub/Sub.
Alternatively, having multiple nodes will make it unlikely that they will all be down at the time of receiving a notification.

This problem is linked to the fact that the Redis cluster is managed, and as such remote clients can't call CONFIG on it. When enabling the Spring keyspace event listener, it tries to configure Redis to emit keyspace expiry events, by setting the notify-keyspace-events config key to "Ex".

The workaround to this is:

1. Configure your MemoryStore on GCP, adding the notify-keyspace-events key with "Ex" as value.
2. Use @EnableRedisRepositories(enableKeyspaceEvents = EnableKeyspaceEvents.ON_STARTUP, keyspaceNotificationsConfigParameter = "") for your client configuration. The explicitely empty String prevents Spring from trying to override the remote configuration.