搭建redis高可用：主从、哨兵、集群

最新推荐文章于 2022-07-08 16:46:04 发布
最新推荐文章于 2022-07-08 16:46:04 发布
阅读量381 收藏
点赞数
文章标签： redis docker 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhenyong/article/details/124945783
版权

搭建主从

version: "3"

networks:
  redis-replication:
    driver: bridge
    ipam:
      config:
        - subnet: 172.25.0.0/24

services:
  master:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-master
    ports:
      - "6379:6379"
    volumes:
      - "./master/redis.conf:/etc/redis.conf"
      - "./master/data:/data"
    command: redis-server /etc/redis.conf
    restart: always
    networks:
      redis-replication:
        ipv4_address: 172.25.0.101

  slave1:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-slave-1
    ports:
      - "6380:6379"
    volumes:
      - "./slave1/redis.conf:/etc/redis.conf"
      - "./slave1/data:/data"
    command: redis-server --slaveof redis-master 6379
    restart: always
    networks:
      redis-replication:
        ipv4_address: 172.25.0.102

  slave2:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-slave-2
    ports:
      - "6381:6379"
    volumes:
      - "./slave2/redis.conf:/etc/redis.conf"
      - "./slave2/data:/data"
    command: redis-server --slaveof redis-master 6379
    restart: always
    networks:
      redis-replication:
        ipv4_address: 172.25.0.103

执行

docker-compose -f docker-compose-master-slave.yaml up -d

执行即可搭建好
验证：一个输入，在另外节点查询

搭建哨兵

第一步先搭建主从，上面的配置即可
第二步，搭建哨兵
放置的目录

.
├── docker-compose-master-slave.yaml
├── docker-compose-sentinel.yaml
├── sentinel1.conf
├── sentinel2.conf
└── sentinel3.conf

version: '3'
services:
  sentinel1:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-sentinel-1
    ports:
      - 26379:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    restart: always
    volumes:
      - ./sentinel1.conf:/usr/local/etc/redis/sentinel.conf
  sentinel2:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-sentinel-2
    ports:
    - 26380:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    volumes:
      - ./sentinel2.conf:/usr/local/etc/redis/sentinel.conf
  sentinel3:
    image: 10.30.30.22:9080/library/redis:5.0.5
    container_name: redis-sentinel-3
    ports:
      - 26381:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    volumes:
      - ./sentinel3.conf:/usr/local/etc/redis/sentinel.conf
networks:
  default:
    external:
      name: sentinel_redis-replication

sentinel.conf三个配置都一样

# 哨兵sentinel实例运行的端口 默认26379
port 26379
# myid
# 哨兵sentinel的工作目录
dir /tmp
# 自定义集群名，其中 172.25.0.101 为 redis-master 的 ip，6379 为 redis-master 的端口，2 为最小投票数（因为有 3 台 Sentinel 所以可以设置成 2）
sentinel monitor mymaster 172.25.0.101 6379 2

sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel auth-pass mymaster 123456
sentinel failover-timeout mymaster 180000
sentinel deny-scripts-reconfig yes

搭建集群

.
├── cluster-6381.conf
├── cluster-6382.conf
├── cluster-6383.conf
├── cluster-6384.conf
├── cluster-6385.conf
├── cluster-6386.conf
└── docker-compose-cluster.yaml

version: '3'
services:
 redis-6381:
  container_name: redis-cluster-1
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6381:6381"
  volumes:
   - ./cluster-6381.conf:/etc/usr/local/redis.conf
   - ./redis-6381/data:/data

 redis-6382:
  container_name: redis-cluster-2
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6382:6382"
  volumes:
   - ./cluster-6382.conf:/etc/usr/local/redis.conf
   - ./redis-6382/data:/data

 redis-6383:
  container_name: redis-cluster-3
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6383:6383"
  volumes:
   - ./cluster-6383.conf:/etc/usr/local/redis.conf
   - ./redis-6383/data:/data

 redis-6384:
  container_name: redis-cluster-4
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6384:6384"
  volumes:
   - ./cluster-6384.conf:/etc/usr/local/redis.conf
   - ./redis-6384/data:/data

 redis-6385:
  container_name: redis-cluster-5
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6385:6385"
  volumes:
   - ./cluster-6385.conf:/etc/usr/local/redis.conf
   - ./redis-6385/data:/data

 redis-6386:
  container_name: redis-cluster-6
  image: 10.30.30.22:9080/library/redis:5.0.5
  command: redis-server /etc/usr/local/redis.conf
  ports:
   - "6386:6386"
  volumes:
   - ./cluster-6386.conf:/etc/usr/local/redis.conf
   - ./redis-6386/data:/data

protected-mode no
#bind 127.0.0.1
port 6381
# 开启集群模式
cluster-enabled yes

protected-mode no
#bind 127.0.0.1
port 6382
# 开启集群模式
cluster-enabled yes

protected-mode no
#bind 127.0.0.1
port 6383
# 开启集群模式
cluster-enabled yes

protected-mode no
#bind 127.0.0.1
port 6384
# 开启集群模式
cluster-enabled yes

protected-mode no
#bind 127.0.0.1
port 6385
# 开启集群模式
cluster-enabled yes

protected-mode no
#bind 127.0.0.1
port 6386
# 开启集群模式
cluster-enabled yes

启动容器

docker-compose -f docker-compose-cluster.yaml up -d

配置槽位

docker exec -it redis-cluster-1 redis-cli -p 6381 --cluster fix localhost:6381
docker exec -it redis-cluster-2 redis-cli -p 6382 --cluster fix localhost:6382
docker exec -it redis-cluster-3 redis-cli -p 6383 --cluster fix localhost:6383
docker exec -it redis-cluster-4 redis-cli -p 6384 --cluster fix localhost:6384
docker exec -it redis-cluster-5 redis-cli -p 6385 --cluster fix localhost:6385
docker exec -it redis-cluster-6 redis-cli -p 6386 --cluster fix localhost:6386

配置集群

查找每个节点的ip并进行配置
查找对应ip命令

docker exec -it redis-cluster-1 cat /etc/hosts

配置集群关联

docker exec -it redis-cluster-1 redis-cli -p 6381 --cluster create 172.27.0.4:6381 172.27.0.2:6382 172.27.0.6:6383 172.27.0.5:6384 172.27.0.3:6385 172.27.0.7:6386 --cluster-replicas 1

遇到需要输入，输入yes即可

java使用

.
├── Dockerfile
├── pom.xml
└── src
    └── main
        ├── java
        │   └── com
        │       └── github
        │           └── test
        │               ├── DemoApplication.java
        │               ├── config
        │               │   └── RedisConfig.java
        │               └── controller
        │                   └── DemoController.java
        └── resources
            └── application.yml

package com.isyscore.os.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(om.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    //字符串建议使用StringRedisTemplate
    @Bean("stringRedisTemplate")
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}


/**
* @author shizi
* @since 2022-05-24 10:19:26
*/
@RequestMapping("api/demo")
@RestController
public class DemoController {
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @GetMapping("set/{key}/{value}")
    private String setValue(@PathVariable("key") String key, @PathVariable("value") String value) {
        stringRedisTemplate.opsForValue().set(key, value, 1, TimeUnit.HOURS);
        return "ok";
    }
    
    @GetMapping("get/{key}")
    private String getValue(@PathVariable("key") String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

spring:
  redis:
    host: 172.17.0.2
    port: 6379
#    sentinel:
#      master: mymaster
#      nodes:
#        - 172.25.0.2:26379
#        - 172.25.0.3:26379
#        - 172.25.0.4:26379
    cluster:
      nodes:
        - 172.27.0.4:6381
        - 172.27.0.2:6382
        - 172.27.0.6:6383
        - 172.27.0.5:6384
        - 172.27.0.3:6385
        - 172.27.0.7:6386


<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.6.RELEASE</version>
</parent>

<groupId>com.isyscore.os</groupId>
<artifactId>isc-redis-test</artifactId>
<version>1.0.0</version>

<dependencies>
  <!-- redis start -->
  <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
  </dependency>
  
  <dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
  </dependency>
  
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
  </dependency>
  
  <dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
  </dependency>
  
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
  </dependency>
  <!-- redis end -->
  
  <!-- spring -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-actuator-autoconfigure</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-actuator</artifactId>
  </dependency>
 </dependencies>
<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

FROM docker.io/itoak/java8:1.0.0
# 容器启动后的工作目录
WORKDIR /opt
# 将jar包添加到容器内
ADD xxx.jar server.jar
# 容器启动后 执行命令
CMD java -jar server.jar

打容器镜像（标签自行打，我这里是哨兵使用sentinel，集群使用cluster）

docker build -t redis-java-test:sentinel .
docker build -t redis-java-test:cluster .

运行时候有不同，要将对应的测试镜像所在网络与哨兵或者集群应该在同一个网络

docker network ls

上面的哨兵和集群配置最后生成的网络分别如下，在运行测试用例的时候要带上对应的网络

  • cluster_default：这个是集群的网络
  • sentinel_redis-replication：这个是哨兵的网络

哨兵下的运行命令

docker run --network sentinel_redis-replication --name redis-java-sentinel -d -p 28080:8080 redis-java-test:sentinel

集群下的运行命令

docker run --network cluster_default --name redis-java-cluster -d -p 28081:8080 redis-java-test:cluster

go使用

go代码这里使用了go-redis，不过进行了一些封装，使用方式请见https://github.com/isyscore/isc-gobase/tree/main/redis

go get github.com/isyscore/isc-gobase�

.
├── Dockerfile
├── application.yml
├── go.mod
└── main.go

#build stage
FROM golang:1.18 as builder

RUN go version

ENV GO111MODULE=on
ENV GOPROXY=https://goproxy.cn

WORKDIR /app

COPY . /app/

RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /app
EXPOSE 8081

#image stage
FROM alpine:latest

WORKDIR /app

ENV TZ=Asia/Shanghai
ENV ZONEINFO=/app/zoneinfo.zip

COPY --from=builder /app/application.yml /app/application.yml
#COPY --from=builder /app/config/application-default.yml /app/config/application-default.yml
COPY --from=builder /app/base-redis-test /app/base-redis-test
COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /app

CMD ["./base-redis-test"]

base:
  application:
    name: sample
  server:
    enable: true
    port: 32005
    gin:
      # 有三种模式：debug/release/test
      mode: debug
  redis:
    enable: true
#    standalone:
#      addr: redis-standalone:6379
#    sentinel:
#      master: mymaster
#      addrs:
#        - redis-sentinel-1:26379
#        - redis-sentinel-2:26379
#        - redis-sentinel-3:26379
    cluster:
      addrs:
        - localhost:6381
        - localhost:6382
        - localhost:6383
        - localhost:6384
        - localhost:6385
        - localhost:6386
      max-redirects: 4

构建

go build

然后执行打镜像，镜像手法与java同样

老柿子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
Redis系列之高可用集群
qq_39024365的博客
01-05 422
Redis，一个完全免费开源的缓存软件，它是使用C语言编写，基于内存的高性能key-value数据库。Redis在互联网存储技术中得到非常广泛的应用，它作为缓存中间件，能够解决互联网应用中的一些技术瓶颈，且具有使用简单，性能强悍，功能应用场景丰富的特点。 Redis如何打造高可用的架构呢？持久化+主从+哨兵 持久化 Redis持久化的方式有两种：RDB和AOF RDB是把Redis存储...
docker-compose redis主从哨兵 redis多节点高可用 redis集群高可用
04-12
docker-compose 形式部署 redis 1主2从3哨兵 redis 多节点高可用 redis 主从哨兵 redis 集群高可用 redis 哨兵 redis 高可用
架构设计：系统存储（17）——Redis集群方案：高可用
热门推荐
JAVA入门中
12-20 1万+
从本篇文章开始，我们将向读者介绍几种Redis的高可用高负载集群方案。除了介绍Redis 3.X版本中推荐的原生集群方案外，还会介绍使用第三方组件搭建Redis集群的方法。本文我们会首先介绍Redis的高可用集群方案。
Redis系列九：redis集群高可用
weixin_34051201的博客
02-04 80
Redis集群的概念： 　　RedisCluster是redis的分布式解决方案，在3.0版本后推出的方案，有效地解决了Redis分布式的需求，当一个服务挂了可以快速的切换到另外一个服务，当遇到单机内存、并发等瓶颈时，可使用此方案来解决这些问题 一、分布式数据库概念 1.分布式数据库把整个数据按分区规则映射到多个节点，即把数据划分到多个节点上，每个节点负责整体数据的一个子集。比如我们库有9...
redis高可用集群
Li_zhong_jie的博客
04-12 1602
一、redis集群方案比较 主从哨兵模式 redis3.0之前的版本实现集群一般采用的方案是借助哨兵sentinel工具来监控master节点的状态，如果master主节点异常，则会做主从切换，将一台slave机器作为master。哨兵的配置稍微复杂，并且性能和高可用方面表现一般，主从切换瞬间存在访问瞬断的情况，而且哨兵模式只有一个主节点对外服务，没办法支持很高的并发。并且这单个主节点内存不宜设置过大，否则会导致持久化文件过大，影响数据恢复和主从同步。 高可用集群模式 redis集群是一个由多个主从节点群
Redis 集群高可用
杨宇昌的博客
04-25 738
redis 主从复制、哨兵集群、cluster集群
Redis高可用之哨兵+主从模式总结
04-29
在这个场景下，主从模式和哨兵模式结合使用，可以构建出一套高效且可靠的 Redis 高可用解决方案。 1. **主从模式**： 主从模式是 Redis 提供的一种基础的高可用策略，它通过数据复制来实现读写分离。主节点负责...
Redis集群-Redis安装、Redis主从复制、哨兵、Redis集群
最新发布
12-25
Redis集群是Redis的一种高可用性解决方案，通过主从复制、哨兵和集群三大技术模块来实现高可用性和可扩展性。本文将对Redis集群进行详细的介绍，包括Redis安装、主从复制、哨兵和集群的配置和实现。 一、Redis安装 ...
深入学习Redis高可用架构：哨兵原理及实践
02-25
本文将要介绍的哨兵，它基于Redis主从复制，主要作用便是解决主节点故障恢复的自动化问题，进一步提高系统的高可用性。（注：文章内容基于Redis3.0版本）在介绍哨兵之前，首先从宏观角度回顾一下Redis实现高可用相关...
Docker搭建redis主从+哨兵模式集群.docx
07-27
Docker搭建Redis主从+哨兵模式集群 本文档主要介绍了使用Docker搭建Redis主从复制和哨兵模式集群的步骤。下面是详细的知识点总结： 一、Docker安装 * 下载Docker二进制文件（离线安装包），使用wget命令下载 * ...
golang(gin)整合mysql,整合redis通用脚手架
04-06
golang(gin)整合mysql,整合redis通用脚手架
Nginx+Tomcat+Redis搭建高性能负载均衡集群Session共享
11-24
Nginx+Tomcat+Redis搭建高性能负载均衡集群Session共享
redis最全详解-03-Redis缓存高可用集群
wangzhipeng47的博客
07-29 164
redis最全详解-03-Redis缓存高可用集群 1、Redis集群方案比较 哨兵模式 在redis3.0以前的版本要实现集群一般是借助哨兵sentinel工具来监控master节点的状态，如果master节点异常，则会做主从切换，将某一台slave作为master，哨兵的配置略微复杂，并且性能和高可用性等各方面表现一般，特别是在主从切换的瞬间存在访问瞬断的情况，而且哨兵模式只有一个主节点对外提供服务，没法支持很高的并发，且单个主节点内存也不宜设置得过大，否则会导致持久化文件过大，影响数据恢.
redis主从+哨兵集群搭建
平头哥的博客
11-19 519
redis的应用场景很多，不管是在数据存储还是分布式锁等方面，本篇文章主要对主从、哨兵集群做一个简单的搭建，不会太复杂。
gin redis 链接不上_Redis的三种模式：主从、哨兵、集群
weixin_39531688的博客
11-02 249
前言 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。普遍用于目前主流的分布式架构系统中，关于redis的详细介绍，见另一篇文章：redis的安装与介绍​blog.csdn.netredis的多机数据库实现，主要分为以下三种：Redis哨兵（Sentinel）Redis复制（主从）Redis集群一、Re...
redis主从与哨兵集群的搭建
此后如竟没有炬火，我便是唯一的光。
04-03 1121
[redis6.2.6版本下载地址](https://download.redis.io/releases/redis-6.2.6.tar.gz) [redis官网](https://redis.io/) [redis官方文档](https://redis.io/docs Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。(是一个非关系型的数据库)
go操作redis
k393393的博客
01-22 742
1.redis简单介绍 redis是一个高性能的key-value数据库 redis特点：     1）.支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用     2）.不仅仅支持简单的key-value类型的数据            还提供string、list（链表）、set（集合）
Go语学习笔记 - redis单节点模式 | Web框架Gin（十二）
阿良的博客
07-08 2191
在前面几篇主要是说gorm对数据库的一些操作，后面可能还会继续。 本文主要写一下redis单节点的初始化和操作。
266-Redis的主从复制
LINZEYU666的博客
04-08 292
Redis的主从复制 概念 主从复制：指的是将一个Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点（master/leader),后者称为从节点（slave/follower）。 数据的复制是单向的 ，只能从主节点到从节点。Master以写为主，Slave以读为主。 默认情况下，每台Redis服务器都是主节点，且一个主节点可以有多个从节点（或者没有从节点），但一个从节点只能有一个主节点。 主就是写，从就是读，从上的数据是主结点复制给从结点的。 在网络应用中，读是比较多的，从结点多。 高可
redis主从哨兵集群
08-26
Redis主从哨兵集群是一种常见的Redis高可用架构，用于提供数据的冗余备份和故障切换。在这种集群中，有一个主节点和多个从节点，还有若干个哨兵节点。 主节点负责处理所有的写操作和读操作，并将写操作的结果同步到从节点。从节点起到备份的作用，可以接收主节点的数据同步，并可以提供读操作的服务。 哨兵节点的作用是监控主节点和从节点的状态，当主节点宕机或发生故障时，哨兵节点会自动进行故障切换，选举一个新的主节点，并将其他从节点切换到新的主节点上。 哨兵节点还可以进行故障恢复、配置管理、监控报警等功能，保证Redis集群的高可用性和稳定性。 通过Redis主从哨兵集群，可以提高系统的可靠性和性能，同时实现故障自动切换和数据备份，保证数据的安全性和持久性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值