在Spring Cloud微服務項目中遇到Redis CPU飙升的問題時，可以按照以下步驟進行排查和解決：

監控和分析

在監控和分析Redis性能時，關注CPU使用率、記憶體使用、網絡流量和指令統計等是非常關鍵的。下面我将詳細說明如何使用Redis自帶的指令和監控工具。

1.使用Redis自帶的INFO指令

指令介紹： INFO指令用于擷取Redis伺服器的狀态資訊，包括記憶體、CPU、用戶端連接配接、持久化等各方面的詳細資料。
執行個體代碼：

redis-cli INFO

這條指令将輸出大量的資訊，您可以根據需要關注特定的部分，例如memory用于記憶體資訊，cpu用于CPU使用情況。

關鍵名額解讀：

used_memory：Redis配置設定器配置設定的記憶體總量，過高可能表示記憶體洩漏或緩存過大。
used_cpu_sys：Redis伺服器耗費的系統CPU時間。
connected_clients：目前連接配接的用戶端數量，過多的連接配接可能會導緻性能下降。

2.使用redis-cli --stat

指令介紹： redis-cli --stat 提供了一個實時更新的界面，顯示關鍵的Redis性能名額。
執行個體代碼：

redis-cli --stat

這個指令将實時顯示操作次數、網絡流量、已連接配接用戶端數等資訊。

3.使用redis-top或第三方監控工具

工具介紹： redis-top是一個第三方的實時監控工具，類似于Linux的top指令，專門為Redis設計。

第三方監控工具，如Prometheus和Grafana，可以提供更詳細的監控和圖形化界面。

安裝和使用redis-top：

git clone https://github.com/myzhan/redis-top.git
cd redis-top
python redis-top.py

這将啟動redis-top，并顯示實時資料。

配置Prometheus和Grafana監控（更進階）：

安裝Prometheus和Grafana。
配置Prometheus以從Redis收集名額。
在Grafana中建立儀表闆來展示這些名額。

關注名額

CPU使用率：高CPU使用率可能表示Redis正在處理大量請求或遇到了性能問題。
記憶體使用：記憶體洩漏、不當的鍵設計或大key可能導緻記憶體使用不斷增加。
網絡流量：監控網絡流量有助于識别是否存在大量的資料傳輸或頻繁的小資料傳輸，這可能會影響Redis的性能。
指令統計：了解Redis處理的指令類型和頻率，可以幫助識别哪些操作最耗資源。

确定熱點操作

确定熱點操作是解決Redis性能問題的關鍵一環，主要通過兩種方式：使用SLOWLOG指令查找執行時間較長的指令，和使用MONITOR指令實時監控Redis操作。下面将詳細說明這兩個指令的使用方法和思考步驟。

1.使用SLOWLOG指令查找慢查詢

指令介紹： SLOWLOG指令用于記錄執行時間超過指定門檻值的指令。這有助于識别耗時的操作，是性能優化的重要參考。
執行個體代碼：

redis-cli SLOWLOG GET 10

此指令傳回最近的10條慢查詢。

分析和思考：

檢視慢查詢的具體指令和執行時間。
分析導緻查詢變慢的原因，如大key操作、複雜的資料結構操作等。

設定慢查詢門檻值：

redis-cli CONFIG SET slowlog-log-slower-than <microseconds>

這個指令可以設定慢查詢的門檻值，機關是微秒。

2.使用MONITOR指令實時監控Redis操作

指令介紹： MONITOR是一個調試指令，它實時列印出伺服器接收到的每一個指令，用于實時監控和診斷。
執行個體代碼：

redis-cli MONITOR

運作此指令後，你會看到所有通過Redis執行的指令。

分析和思考：

監控指令輸出，尋找頻繁出現的操作。
注意大key操作，如對大hash或大list的操作。
監測是否有不合理的全鍵掃描（如KEYS *）。

代碼層面排查

代碼層面的排查是定位和解決Redis性能問題的關鍵步驟之一。在微服務架構中，不同的服務可能以不同的方式與Redis互動，是以需要仔細稽核相關代碼。以下是進行代碼層面排查的步驟和執行個體：

1. 稽核頻繁的讀寫操作

問題：頻繁的讀寫操作可能導緻Redis CPU使用率升高和響應時間延遲。
排查方法：

審查代碼，尋找大量重複的Redis讀寫操作，特别是在循環中的操作。
檢查是否有未使用緩存或緩存過期政策不當的情況。

代碼示例（Java使用Jedis）：

Jedis jedis = new Jedis("localhost");
for (int i = 0; i < 10000; i++) {
    jedis.set("key" + i, "value" + i); // 頻繁寫操作
    jedis.get("key" + i); // 頻繁讀操作
}
jedis.close();

2. 檢查大key操作

問題：大key操作會占用大量記憶體和CPU資源，影響Redis性能。
排查方法：

檢查是否有将大量資料存儲在單個key中的情況，如大清單、大哈希表等。
使用MEMORY USAGE key指令檢查key的記憶體占用。

代碼示例：

Jedis jedis = new Jedis("localhost");
// 假設有一個大的清單
for (int i = 0; i < 100000; i++) {
    jedis.lpush("largeList", "element" + i);
}
jedis.close();

這段代碼建立了一個非常大的清單，可能導緻性能問題。

3. 避免不必要的全鍵掃描

問題：使用如KEYS指令進行全鍵掃描會阻塞Redis并消耗大量CPU資源。
排查方法：

審查代碼，查找是否使用了KEYS等全鍵掃描指令。
考慮使用更高效的指令，如SCAN。

代碼示例：

Jedis jedis = new Jedis("localhost");
Set<String> keys = jedis.keys("*"); // 不推薦在生産環境使用
for (String key : keys) {
    // 對key進行操作
}
jedis.close();

這段代碼使用了KEYS指令進行全鍵掃描，可能導緻性能問題。

連接配接管理

在微服務架構中，合理管理Redis的連接配接非常關鍵，因為不恰當的連接配接管理可能會導緻性能問題。下面我們詳細探讨如何檢查和配置Redis的連接配接數和連接配接池，并提供相應的執行個體代碼。

1.檢查Redis連接配接數

使用INFO指令：

redis-cli INFO clients

這個指令可以顯示目前連接配接到Redis的用戶端數量和一些相關資訊。

關鍵名額：

connected_clients：目前已連接配接的用戶端數量。
maxclients：伺服器配置的最大用戶端連接配接數。

2.配置連接配接池

連接配接池的使用可以有效減少頻繁建立和銷毀連接配接的開銷，提升性能。

Java中使用Jedis連接配接池的示例

建立連接配接池配置：

JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(50); // 最大連接配接數
poolConfig.setMaxIdle(10);  // 最大空閑連接配接數
poolConfig.setMinIdle(5);   // 最小空閑連接配接數
poolConfig.setTestOnBorrow(true); // 在擷取連接配接的時候檢查有效性

建立Jedis連接配接池：

JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

使用連接配接池：

try (Jedis jedis = jedisPool.getResource()) {
    // 執行Redis操作
    jedis.set("key", "value");
    String value = jedis.get("key");
    // ...
} // 連接配接将自動歸還給連接配接池

Spring Boot中配置連接配接池

如果使用Spring Boot，通常可以在application.yml或application.properties中配置。

在application.yml中配置：

spring:
  redis:
    host: localhost
    port: 6379
    jedis:
      pool:
        max-active: 50  # 最大連接配接數
        max-idle: 10    # 最大空閑連接配接數
        min-idle: 5     # 最小空閑連接配接數

使用RedisTemplate：在Spring Boot應用中，可以直接注入RedisTemplate或StringRedisTemplate來執行操作。

Redis配置調優

對Redis進行配置調優是提高其性能和穩定性的重要步驟。這包括調整記憶體管理、選擇合适的持久化政策以及優化其他相關配置。以下是一些主要的調優方向和示例。

1. 調整maxmemory政策

問題：當Redis用作緩存時，如果記憶體不足以容納所有資料，就需要一種機制來決定哪些資料被移除。
解決方案：設定maxmemory配置，并選擇一個适當的淘汰政策。
配置示例：

CONFIG SET maxmemory 100mb
CONFIG SET maxmemory-policy allkeys-lru

這個例子設定了最大記憶體為100MB，并采用了allkeys-lru（最近最少使用）政策，當記憶體達到限制時，會淘汰最近最少使用的鍵。

2. 優化持久化設定

Redis支援兩種主要的持久化方式：RDB（快照）和AOF（隻追加檔案）。

RDB持久化

優點：RDB是一種高效的方式來儲存Redis在某一時刻的資料快照。
配置示例：

CONFIG SET save "60 10000"  # 60秒内如果超過10000次更新則觸發RDB持久化

AOF持久化

優點：AOF記錄每次寫操作，重新開機時通過重放這些操作來恢複資料。
配置示例：

CONFIG SET appendonly yes
CONFIG SET appendfsync everysec  # 每秒同步一次到磁盤

3. 其他性能相關的配置

TCP連接配接設定：

CONFIG SET tcp-keepalive 60

設定TCP保持活動的時間，有助于防止網絡裝置意外關閉空閑連接配接。

禁用不必要的指令：如果某些危險指令（如FLUSHALL、KEYS）不需要在生産環境中使用，可以考慮禁用它們以提高安全性。

硬體資源檢查

硬體資源對于確定Redis和整個微服務架構的性能至關重要。如果硬體資源不足，無論如何優化代碼或Redis配置，都可能無法達到理想的性能。以下是檢查和評估伺服器硬體資源的步驟及相關建議。

1. 檢查CPU使用率

重要性：高CPU使用率可能會導緻Redis響應緩慢。
檢查方法：可以使用作業系統提供的工具，如Linux中的top或htop指令。
指令示例：

top

在top界面中，檢視%Cpu(s)字段來了解CPU使用情況。

2. 檢查記憶體使用

重要性：Redis是基于記憶體的存儲系統，充足的記憶體對于其性能至關重要。
檢查方法：使用如free指令檢查系統的記憶體使用情況。
指令示例：

free -m

這會顯示以MB為機關的記憶體使用情況，包括總量、已用量和可用量。

3. 磁盤IO性能

重要性：尤其是當使用AOF持久化時，磁盤的IO性能會直接影響Redis的性能。
檢查方法：可以使用iostat工具來檢查。
指令示例：

iostat -dx 2

這會顯示每個裝置的磁盤IO統計資訊。

4. 網絡帶寬

重要性：對于分布式微服務和Redis叢集，網絡帶寬是一個重要的考慮因素。
檢查方法：使用iftop或nload等工具來監控網絡流量。
指令示例：

iftop

這會顯示網絡接口的實時帶寬使用情況。

Redis分片或叢集

當單個Redis執行個體無法滿足性能需求或需要提高可用性時，可以考慮使用Redis分片或叢集。這些方法可以提高Redis的擴充性和容錯能力。

1.Redis分片(Sharding)

分片是将資料分布在多個Redis執行個體上的過程，可以橫向擴充性能和容量。

使用用戶端分片：

用戶端分片是最常見的分片方法，它通過在用戶端邏輯中配置設定鍵到不同的Redis執行個體來實作。
每個執行個體獨立運作，沒有内部通信。

用戶端分片的執行個體代碼

在Spring Boot架構中實作Redis用戶端分片，通常需要使用第三方庫來輔助處理分片邏輯。Spring Boot自身并不直接提供用戶端分片的功能，但可以通過配置多個RedisTemplate或JedisConnectionFactory來實作。下面是一個基于Spring Boot的Redis用戶端分片的簡單示例：

1、添加依賴

首先確定在pom.xml中添加了Redis的依賴，如spring-boot-starter-data-redis。

2、配置多個Redis連接配接工廠

在Spring配置檔案中定義多個JedisConnectionFactory，每個對應一個Redis執行個體。

@Configuration
public class RedisConfig {

 @Bean
    public JedisConnectionFactory redisConnectionFactory1() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("server1", 6379);
        return new JedisConnectionFactory(config);
    }

    @Bean
    public JedisConnectionFactory redisConnectionFactory2() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("server2", 6379);
        return new JedisConnectionFactory(config);
    }

    // 可以根據需要配置更多的Redis連接配接工廠
}

3、建立分片政策

接下來，建立一個簡單的分片政策，用于根據key決定使用哪個Redis執行個體。

public class RedisShardingStrategy {

    private List<JedisConnectionFactory> connectionFactories;

    public RedisShardingStrategy(List<JedisConnectionFactory> connectionFactories) {
        this.connectionFactories = connectionFactories;
    }

    public JedisConnectionFactory getShard(String key) {
        int shardIndex = Math.abs(key.hashCode()) % connectionFactories.size();
        return connectionFactories.get(shardIndex);
    }
}

4、建立RedisTemplate執行個體

為每個JedisConnectionFactory建立對應的RedisTemplate執行個體。

@Bean
public RedisTemplate<String, Object> redisTemplate1() {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory1());
    return template;
}

@Bean
public RedisTemplate<String, Object> redisTemplate2() {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory2());
    return template;
}

// 為其他連接配接工廠建立更多的RedisTemplate執行個體

5、使用分片政策

在服務中使用RedisShardingStrategy來選擇合适的RedisTemplate進行操作。

@Service
public class RedisService {

    private final RedisShardingStrategy shardingStrategy;
    private final List<RedisTemplate<String, Object>> redisTemplates;

    public RedisService(RedisShardingStrategy shardingStrategy, 
                        List<RedisTemplate<String, Object>> redisTemplates) {
        this.shardingStrategy = shardingStrategy;
        this.redisTemplates = redisTemplates;
    }

    private RedisTemplate<String, Object> getRedisTemplate(String key) {
        JedisConnectionFactory factory = shardingStrategy.getShard(key);
        for (RedisTemplate<String, Object> template : redisTemplates) {
            if (template.getConnectionFactory().equals(factory)) {
                return template;
            }
        }
        throw new IllegalStateException("No RedisTemplate found for given key");
    }

    public void setValue(String key, Object value) {
        RedisTemplate<String, Object> template = getRedisTemplate(key);
        template.opsForValue().set(key, value);
    }

    public Object getValue(String key) {
        RedisTemplate<String, Object> template = getRedisTemplate(key);
        return template.opsForValue().get(key);
    }
}

2.Redis叢集(Clustering)

Redis叢集提供了一個更進階的解決方案，通過自動分片和提供資料複制及故障轉移來擴充Redis。

叢集特性：

Redis叢集将資料自動分片到多個節點。
提供資料複制和故障轉移功能，提高可用性。

搭建Redis叢集：

需要至少三個Redis節點來建構一個穩定的叢集。
使用Redis的cluster meet指令将節點互相連接配接。

Redis叢集的配置示例：

假設有三個Redis節點，端口分别為7000、7001、7002。
配置檔案示例（為每個節點建立）：

port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

使用redis-cli --cluster create指令建立叢集。

應用層優化

應用層優化是提高緩存效率和減輕對Redis依賴的重要手段。它涉及到緩存政策的優化、對熱點資料的特殊處理，以及本地緩存和緩存預熱的實作。以下是一些主要的應用層優化政策和示例代碼。

1.緩存政策優化

失效政策：

設定合理的緩存失效時間，避免資料過時或緩存滿載。
對于一些經常通路但不常更新的資料，可以設定較長的緩存時間。

熱點資料處理：

對于頻繁通路的熱點資料，可以采用更高效的緩存政策，如增加副本、使用更快的存儲媒體等。

Java中的緩存操作示例：

public class RedisCache {
    private JedisPool jedisPool;

    public RedisCache(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public String getData(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            // 嘗試從緩存中擷取資料
            String value = jedis.get(key);
            if (value == null) {
                // 如果緩存中沒有，從資料庫或其他地方加載
                value = loadDataFromDB(key);
                // 設定緩存，同時設定過期時間為1小時
                jedis.setex(key, 3600, value);
            }
            return value;
        }
    }

    private String loadDataFromDB(String key) {
        // 加載資料的邏輯...
        return "some_data";
    }
}

2.本地緩存與緩存預熱

本地緩存：

對于高頻通路但更新不頻繁的資料，可以在本地記憶體中緩存，以減少對Redis的通路。
本地緩存可以使用Guava Cache、Caffeine等庫實作。

緩存預熱：

在系統啟動時或定期将熱點資料加載到緩存中，減少冷啟動時的大量資料庫通路。

Java中的本地緩存示例（使用Guava Cache）：

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public class LocalCache {
    private Cache<String, String> cache;

    public LocalCache() {
        cache = CacheBuilder.newBuilder()
                            .maximumSize(1000)
                            .expireAfterWrite(10, TimeUnit.MINUTES)
                            .build();
    }

    public String getData(String key) {
        String value = cache.getIfPresent(key);
        if (value == null) {
            value = loadDataFromDB(key);
            cache.put(key, value);
        }
        return value;
    }

    private String loadDataFromDB(String key) {
        // 加載資料的邏輯...
        return "some_data";
    }
}

壓力測試

進行壓力測試是評估和優化系統性能的重要環節，尤其是對于像Redis這樣的緩存系統。在非生産環境中進行壓力測試可以幫助發現潛在的性能瓶頸，進而優化系統的整體表現。以下是進行Redis壓力測試的一些步驟和建議：

1. 選擇壓力測試工具

對于Redis，常用的壓力測試工具有：

redis-benchmark：Redis自帶的性能測試工具，可以快速進行基礎性能測試。
JMeter：一個廣泛使用的性能測試工具，可以進行更複雜的測試場景模拟。
自定義腳本：基于你的具體需求編寫測試腳本，模拟真實的應用場景。

2. 設定測試環境

確定測試環境與生産環境盡可能相似，包括硬體配置、網絡環境和資料量。
在非生産環境進行測試，以避免影響正常業務。

3. 使用redis-benchmark進行基本測試

指令示例

redis-benchmark -h redis-host -p 6379 -c 100 -n 100000

複制代碼

redis-benchmark -h redis-host -p 6379 -c 100 -n 100000

這個指令意味着：

-h redis-host：指定Redis伺服器的位址。
-p 6379：指定Redis伺服器端口。
-c 100：使用100個并發連接配接。
-n 100000：總共發送100000個請求。

測試内容

測試不同類型的操作，如GET、SET等。
觀察響應時間和吞吐量。

4. 使用JMeter進行進階測試

測試計劃設定

在JMeter中設定測試計劃，包括線程組（模拟使用者數）、采樣器（指定Redis指令）和監聽器（結果展示）。

執行個體使用

JMeter通常通過圖形界面進行配置，不涉及代碼編寫。但可以通過JMeter的腳本語言來編寫更複雜的測試邏輯。

5. 分析測試結果

分析吞吐量、響應時間和資源使用率（如CPU、記憶體使用）。
确定性能瓶頸，如是否是網絡延遲、Redis配置或硬體資源限制導緻。

6. 調整和優化

根據測試結果調整Redis配置，如調整連接配接數、記憶體大小等。
優化應用邏輯，比如改善資料通路模式、減少不必要的操作。

7. 重複測試

在做出改進後，重複測試以驗證優化效果。
持續監控和測試，以確定系統在不斷變化的負載下保持穩定性能。

進行壓力測試時，重要的是要確定測試場景盡可能地模拟真實的使用情況。這可能包括模拟高并發請求、大量資料寫入、長時間運作等情況。通過這些測試，可以有效地發現和解決系統在高負載下可能遇到的問題。

注意事項

逐漸增加負載：開始時應使用較低的負載進行測試，逐漸增加，直到達到預期的最高負載。
監控資源使用情況：在進行測試時，持續監控伺服器的CPU、記憶體、磁盤I/O和網絡帶寬使用情況。
測試資料準備：確定測試資料的真實性和多樣性，以便測試能夠覆寫不同的使用場景。
測試結果記錄：詳細記錄測試結果，包括測試條件、執行操作的數量和類型以及系統的響應。
安全備份：在開始測試前確定對現有資料進行備份，避免測試過程中資料丢失或損壞。

通過這些步驟和注意事項，可以有效地進行Redis壓力測試，并根據測試結果進行适當的優化和調整。

持續監控

持續監控Redis的性能是確定系統穩定運作的關鍵環節。它可以幫助你及時發現和響應新出現的問題，進而保持系統的高效和可靠性。以下是進行Redis持續監控的幾個關鍵步驟和建議。

1. 選擇監控工具

對于Redis，有多種監控工具可供選擇：

Redis自帶指令：如INFO, MONITOR, 和SLOWLOG等。
開源監控工具：如Prometheus結合Grafana，Redis Exporter。
商業監控工具：如Datadog, New Relic, RedisInsight。

2. 關鍵性能名額

監控時應關注以下關鍵性能名額：

記憶體使用情況：包括總記憶體使用量和記憶體碎片率。
CPU使用率：監控Redis程序的CPU使用情況。
用戶端連接配接數：活躍連接配接數和拒絕的連接配接數。
吞吐量：每秒指令數。
慢查詢日志：記錄執行時間過長的指令。

3. 使用Prometheus和Grafana進行監控

以下是使用Prometheus和Grafana進行Redis監控的基本步驟：

安裝Prometheus Redis Exporter

Redis Exporter是一個Prometheus Exporter，用于收集Redis的性能名額并使其可用于Prometheus。

docker run -d --name redis_exporter -p 9121:9121 oliver006/redis_exporter

配置Prometheus監控Redis

在Prometheus的配置檔案中添加Redis Exporter作為資料源。

scrape_configs:
  - job_name: 'redis'
    static_configs:
      - targets: ['<REDIS_EXPORTER_ADDRESS>:9121']

使用Grafana展示資料

在Grafana中添加Prometheus作為資料源。
建立儀表闆來展示和分析Redis的性能名額。

4. 設定告警機制

通過配置Prometheus的Alertmanager或使用商業監控工具的告警功能，設定告警規則以便在性能出現問題時及時收到通知。

5.自動化和腳本監控

對于一些特定的監控需求，可以編寫自定義腳本來收集和分析資料。例如，使用Python或Shell腳本定期調用Redis指令，然後将結果發送到監控系統或記錄到日志檔案。

# Python腳本示例 - 使用redis-py庫監控Redis
import redis
import json

redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

def get_redis_info():
    info = redis_client.info()
    print(json.dumps(info, indent=4))

get_redis_info()

6. 日志記錄和分析

使用Redis日志記錄功能，記錄關鍵事件和潛在的問題。
定期分析日志檔案，查找異常模式或潛在的問題。

以上步驟需要根據具體的系統環境和業務需求進行調整和優化。在處理過程中，建議逐漸實施，避免大規模同時變更，以免引入新的問題。

作者：一隻愛撸貓的程式猿

連結：https://juejin.cn/post/7323484289353908287

在Spring Cloud微服務項目中遇到Redis CPU飙升