Wie Spring Boot die Master-Slave-Sentinel-Methode von Redis integriert

springboot integriert Redis Master-Slave-Sentinel

Ein Master, zwei Slaves und drei Sentinel-Konfigurationen

• 1, Master:127.0.0.1:6379

• 2, Slave1:127.0.0.1:6380

• 3 .slave2: 127.0.0.1:6381

• 4, sentinel1:127.0.0.1:26379

• 5, sentinel2:127.0.0.1:26479

• 6, sentinel3:127 .0.0. 1:26579

  7、 Überwachungshostname: mymaster
pom-Datei lautet wie folgt:

• port 26379
  sentinel monitor mymaster 127.0.0.1 6379 2
  sentinel down-after-milliseconds mymaster 5000
  sentinel parallel-syncs mymaster 1
  sentinel failover-timeout mymaster 15000

  Ändern Sie die Konfigurationsdatei application.properties

Fügen Sie den folgenden Inhalt zur Konfigurationsdatei hinzu:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>com.chhliu.springboot.redis</groupId>
	<artifactId>springboot-redis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>springboot-redis</name>
	<description>Demo project for Spring Boot redis</description>
 
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.7</java.version>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
 
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

Neuer Redis-Dienst

########################################################
###REDIS (RedisProperties) redis基本配置；
########################################################
# database name
spring.redis.database=0
# server host1 单机使用，对应服务器ip
#spring.redis.host=127.0.0.1  
# server password 密码，如果没有设置可不配
#spring.redis.password=
#connection port  单机使用，对应端口号
#spring.redis.port=6379
# pool settings ...池配置
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
# name of Redis server  哨兵监听的Redis server的名称
spring.redis.sentinel.master=mymaster
# comma-separated list of host:port pairs  哨兵的配置列表
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26479,127.0.0.1:26579

Die abhängige Vo lautet wie folgt:

package com.chhliu.springboot.redis; 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
@Service("redisService")
public class RedisService {
	@Autowired //操作字符串的template，StringRedisTemplate是RedisTemplate的一个子集
	private StringRedisTemplate stringRedisTemplate;
	
	@Autowired  // RedisTemplate，可以进行所有的操作
        private RedisTemplate<Object,Object> redisTemplate;  
	
	public void set(String key, String value){
		stringRedisTemplate.opsForValue().set(key, value);
	}
	
	public void set(Student s){
		redisTemplate.opsForValue().set(s.getId(), s);
	}
	
	public String get(String key){
		return stringRedisTemplate.opsForValue().get(key);
	}
	
	public Student getStudent(String key){
		return (Student) redisTemplate.opsForValue().get(key);
	}
}

Testklasse

package com.chhliu.springboot.redis; 
import java.io.Serializable; 
public class Student implements Serializable{ 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String id;	
	private String name;	
	private String age;	
	private String grade; 
       // 省略getter,setter
	/**
	 * attention:
	 * Details：TODO
	 * @author chhliu
	 * 创建时间：2017-1-18 下午2:24:39
	 * @return
	 */
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", grade=" + grade + "]";
	}
}

Testergebnisse

Name: chhliu

Schüler [ID=001, Name=chhliu, Alter=28, Klasse=erste Klasse]

Redis Sentinel-Modus Sentinel ist in Springboot integriert

Redis' Der Sentinel-Modus ist eine offizielle Hochverfügbarkeitslösung und die Konfiguration ist sehr einfach.

Redis-Cluster installieren

Dieser Artikel verwendet Redis-5.0.5. Sie müssen ein neues /soft/redis/data-Verzeichnis erstellen

vim config/redis-6379. Conf

package com.chhliu.springboot.redis; 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {	
	@Autowired
	private RedisService service;
 
	@Test
	public void contextLoads() {
		service.set("myname", "chhliu");
		Student s = new Student();
		s.setId("001");
		s.setName("chhliu");
		s.setGrade("一年级");
		s.setAge("28");
		service.set(s);
		
		String name = service.get("myname");
		System.out.println("name:"+name);
		
		Student stu = service.getStudent("001");
		System.out.println(stu);
	} 
}

Von Knoten 1 Konfiguration

Vim Config/Redis-6380.CONF

# bind 127.0.0.1 
port 6379
protected-mode no
daemonize yes
pidfile "/var/run/redis_6379.pid"
dir "/soft/redis/data"
dbfilename "dump-6379.rdb"
logfile "log-6379.log"

Konfigurieren

Vim Config/Redis-6381.CONF

# bind 127.0.0.1
port 6380
protected-mode no
daemonize yes
pidfile "/var/run/redis_6380.pid"
dir "/soft/redis/data"
dbfilename "dump-6380.rdb"
logfile "log-6380.log"
 
replicaof 192.168.4.176 6379

E

Konfigurationsbeschreibung

# bind 127.0.0.1 Diese Konfiguration auskommentieren, damit andere Maschinen eine Verbindung zu Redis herstellen könnenprotected-mode nein Deaktivieren Sie den geschützten Modus, damit andere Maschinen eine Verbindung zu Redis herstellen können. Daemonisieren Sie den Start im Hintergrundmodus. Die Version von redis-v5 verwendet Replicaof um den alten Lehrsklaven zu ersetzen.

Starten Sie diese 3 Knoten und führen Sie sie im Verzeichnis /soft/redis aus.

# bind 127.0.0.1
port 6381
protected-mode no
daemonize yes
pidfile "/var/run/redis_6381.pid"
dir "/soft/redis/data"
dbfilename "dump-6381.rdb"
logfile "log-6381.log"
 
replicaof 192.168.4.176 6379

Öffnen Sie den Master-Knoten-Client, um zu sehen, ob die Konfiguration erfolgreich ist.

redis-server config/redis-6379.conf
redis-server config/redis-6380.conf
redis-server config/redis-6381.conf

Konfigurieren Sie 3 weitere Sentinels, um den Cluster zu überwachen 1. 1

vim config/redis-sentinel -26 381 .conf

redis-cli -p 6379
info replication

Konfigurationsanweisungen

port 26379
daemonize yes
pidfile "/var/run/redis-sentinel-26379.pid"
dir /tmp
logfile "log-sentinel-26379.log"
sentinel monitor mymaster 192.168.4.176 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
sentinel deny-scripts-reconfig yes

Der Name des Master-Hosts ist mymaster und die IP-Adresse ist 192.168.4.176. Die folgenden 2 bedeuten, dass es 2 Sentinels gibt, die denken, dass der Master offline ist. Es wird empfohlen, die Anzahl der Sentinel-Knoten auf 2 + 1 zu setzen. Senden Sie eine Ping-Anfrage an den Redis-Knoten. Wenn innerhalb der angegebenen Zeit keine Antwort eingeht, wird davon ausgegangen, dass der Knoten offline geschaltet werden soll.

port 26380
daemonize yes
pidfile "/var/run/redis-sentinel-26380.pid"
dir /tmp
logfile "log-sentinel-26380.log"
sentinel monitor mymaster 192.168.4.176 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
sentinel deny-scripts-reconfig yes

Bei der Durchführung eines Failovers gibt es eine maximale Anzahl von Slave-Knoten, die sich gleichzeitig mit dem neuen Master synchronisieren können. „Starten Sie den Sentinel.“ wieder normal

Führen Sie die Informationsreplikation auf den Knoten 6380 und 6381 aus und stellen Sie fest, dass 6381 zum Masterknoten geworden ist.

Überprüfen Sie die Konfigurationsdateien von 6380 und 6381

port 26381
daemonize yes
pidfile "/var/run/redis-sentinel-26381.pid"
dir /tmp
logfile "log-sentinel-26381.log"
sentinel monitor mymaster 192.168.4.176 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
sentinel deny-scripts-reconfig yes

Starten Sie die Redis-Instanz neu. 6379

monitor mymaster 192.168.4.176 6379 2

637 9 wird zum Sklaven Der Knoten von 6381

RedisTemplate unterstützt derzeit keine Lese- und Schreibtrennung, daher werden die Lese- und Schreibvorgänge zur Verarbeitung an den Masterknoten gesendet, was unangenehmer ist. Führen Sie den obigen Code aus und führen Sie den Monitor auf den drei Redis-Clients aus. Es wurde festgestellt, dass nur der Master die Befehle get und set ausführt und der Slave-Knoten nur den Set-Befehl ausführt.

Das obige ist der detaillierte Inhalt vonWie Spring Boot die Master-Slave-Sentinel-Methode von Redis integriert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!