离线安装docker，docker安装MySQL，Redis，ES，Kibana，mongoDB，RocketMQ

目录

安装docker,docker-compose  

离线安装docker，docker-compose

安装ElasticSearch

安装kibana

下载ik分词器。

安装MySQL

设置MySQL主从（启动单机版MySQL可以不做这一步）

安装Redis

设置Redis主从（启动单机版Redis可以不做这一步）

Redis配置哨兵(一主一从一哨兵) 

 安装mongoDB

mongoDB视图工具

安装RocketMQ

---

众多版本我们可以登陆DockerHUb官网，查看下载我们需要的版本。

有些容器启动没有做文件挂载，但是并不影响容器的运行与使用，容器删除后会造成数据丢失，请根据自己的需求做好文件挂载。

安装docker,docker-compose  

• 使用国内镜像一键安装 

curl -sSL https://get.daocloud.io/docker | sh

• 配置Docker 仓库之后，可以从仓库安装和更新 Docker。        

sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

• 安装 Docker-compose

//下载
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
//添加权限
sudo chmod +x /usr/local/bin/docker-compose

• docker的常用命令

//启动docker
systemctl start docker

//拉取镜像
docker pull :  

//查看自己拉取的镜像
docker images

//启动容器
docker run --name <容器名字> -p <暴露的端口>  -d <后台启动>

//停止容器  | 运行容器
docker stop <容器名字>  |    docker start <容器名字>

//备注：docker镜像和容器的关系，相当云Java的Bean和实例的关系差不多

离线安装docker，docker-compose

• 有些环境下我们无法链接网络，只能通过安装包的方式离线安装。centos7所需的安装包我已下载好，里面有安装步骤。
• 

        链接：度盘链接
        提取码：hhp8 

安装ElasticSearch

• 拉取镜像，我这里下载的是7.13.1版本。

​//拉取es镜像
docker pull elasticsearch:7.13.1

//输入 docker images可以查看自己拉取过的所有镜像

REPOSITORY      TAG           IMAGE ID       CREATED        SIZE
ren             latest        77efb024431b   2 days ago     878MB
nginx           1.21.3-perl   f4285a417127   7 days ago     179MB
redis           6.0.15        2da55ba11193   13 days ago    104MB
mysql           5.7.35        1d7aba917169   2 weeks ago    448MB
elasticsearch   7.13.1        6adeafaff184   3 months ago   854MB
kibana          7.13.1        f9e323cd5f35   3 months ago   1.15GB
java            8             d23bdf5b1b1b   4 years ago    643MB

​

• 运行镜像

docker run --name es -p 9200:9200 -p 9300:9300 
-e ES_JAVA_OTPS="-Xms256m -Xmx256m" 
-e "discovery.type=single-node"  
-p 9200:9200 -p 9300:9300
-d elasticsearch:7.13.1

//--name es 表示给运行的镜像起个名字叫es
//-e ES_JAVA_OTPS="-Xms256m -Xmx256m" ，设置es启动运行时占用的内存（es默认会占用2G内存）
//-e "discovery.type=single-node"  ,设置es为单节点启动（7.13.1版本的es默认集群方式启动）
//-d elasticsearch:7.13.1 ,表示要运行的镜像
//-p 9200:9200 -p 9300:9300，映射端口，9300是TCP协议端口号，ES集群之间通讯端口号，9200端口号，暴露ES RESTful接口端口号

• 输入 docker ps 查看容器是否运行

•  输入《ip:9200》查看是否运行成功

安装kibana

• 拉取镜像

docker pull kibana:7.13.1

//备注：Kibana和ElasticSearch版本号一定要一致，不同版本的可能会导致kibana连接不上ElasticSearch

• 运行镜像

docker run -p 5601:5601 
--name kibana 
--link es 
-e "elasticsearch.hosts=http://elasticsearch:9200" 
-d kibana:7.13.1                  

//--link es 连接elasticsearch镜像，es是你运行elasticsearch时候起的名字

• 安装完成后，打开浏览器输入你的即可使用kibana操作ES。

 

下载ik分词器。

1. ik分词器需要自行下载，你可以登录github下载。（注意版本号，别乱下）

 或者用我下载好的：

链接：https://pan.baidu.com/s/1MIzX_4wfaVYJIRg5hbtIYw 
提取码：1234 

2、使用传输工具上传到你的Linux上，解压后放到ElasticSearch的/plugins目录下。

//刚才启动elasticsearch没有做文件映射，现在需要吧这个文件都拷贝到容器内部。
//  /root/elasticsearch-analysis-ik-7.13.1.zip 是你的压缩包存在的位置
//  es: 是你运行elasticsearch时候起的名字

docker cp /root/elasticsearch-analysis-ik-7.13.1.zip es:/usr/share/elasticsearch/plugins


// 进入容器elasticsearch内部

docker exec -it es /bin/bash

cd plugins


//解压压缩包
unzip elasticsearch-analysis-ik-7.13.1.zip

//解压完成后，删除压缩包
rm -rf elasticsearch-analysis-ik-7.13.1.zip 

exit;//退出镜像

//重启es
docker restart es

3、浏览器输入《Linux的IP：5601》打开kibana查看效果.

• 安装MySQL

•  拉取mysql镜像，MySQL版本众多具体想要什么版本可以登录docker hub查看。

​​​

//我们现在拉取mysql的5.6.51 版本
docker pull mysql:5.6.51


//创建一个文件用来映射容器内部的配置文件

mkdir /root/mysql/config

//运行镜像
docker run --name mysql -p 3306:3306 \
-e  MYSQL_ROOT_PASSWORD=root \
-v /root/mysql/config/:/etc/mysql/conf.d \
-d mysql:5.6.51


//--name mysql:给你运行的镜像起个名字叫mysql
// -e MYSQL_ROOT_PASSWORD=root:传递变量，设置MySQL的密码为root
//-v /root/mysql/config/:/etc/mysql/conf.d： 挂载文件（/root/mysql/config目录的有什么，MySQL容器内的/etc/mysql/conf.d就有什么）.

//不挂载文件以后想要对MySQL的配置文件修改，就需要进入MySQL容器内修改
//-d mysql:5.6.51：表示后台运行


//进入容器内部
docker exec -it <容器名字> /bin/bash

//找到MySQL的配置文件设置编码。
// my.cnf一般在etc/mysql/my.cnf位置。找到后请在以下三部分里添加如下内容： 
[client] 
default-character-set = utf8mb4 
[mysql] 
default-character-set = utf8mb4 
[mysqld] 
character-set-client-handshake = FALSE 
character-set-server = utf8mb4 
collation-server = utf8mb4_unicode_ci 
init_connect='SET NAMES utf8mb4'

//容器内无法使用vim 和 vi命令需要 下载(每个容器内使用都需要)
先：apt-get  update  
在：apt-get install vim

• 设置MySQL主从（启动单机版MySQL可以不做这一步）

• 配置MySQL主从至少要启动两个MySQL。

​​​

• 修改MySQL主的配置文件(mysql-master)。

1. 刚才启动时候做了文件映射的，直接可以在映射的位置新建一个配置文件，添加 一下配置、
2. 没做文件映射的，进入MySQL容器，先找到MySQL的my.cnf 文件,添加上面的内容，my.cnf在etc/mysql/下，或者在/etc/mysql/conf.d下面新建一个×××.cnf配置文件也可以。

​​​

    添加的内容：

​​​

•  修改MySQL从的配置文件(mysql-slaver)。

1. 进入MySQL从容器内部，还是同一个目录下，修改同一个文件，添加配置如下。

 ​​​

• 连接上图形化工具，添加以下内容（关闭防火墙不然连不上）

1. 查看MySQL主和从是否开启日志

SHOW GLOBAL VARIABLES LIKE '%log%'

​​​

1.   一下在MySQL主操作

//全部在主MySQL中操作

// 创建一个用户,账号master,密码master
GRANT REPLICATION SLAVE ON *.* TO 'master'@'%' IDENTIFIED BY 'master';

//账号授权	
GRANT ALL ON *.* TO 'master'@'%';

//刷新，让配置生效
FLUSH PRIVILEGES;

1. 查询主数据库的状态信息，用来在从数据同步数据。

//在从数据库查询，主节点状态
SHOW MASTER status

​​​

1.  一下在MySQL从库操作     

//一下命令在MySQL从数据库操作

//在主数据库上面创建的那个用户，连接主MySQL服务器，用来同步数据
CHANGE MASTER TO MASTER_HOST="82.156.190.100",
MASTER_PORT=3308,
MASTER_USER="master",MASTER_PASSWORD="master",
MASTER_LOG_FILE="f08252e11999-bin.000002",	
MASTER_LOG_POS=313;

//详细介绍
MASTER_HOST="82.156.190.100"  //改成你的ip
MASTER_PORT=3308  //mysql主  占用的端口
MASTER_USER="master"     //刚才创建用户时候的账号
MASTER_PASSWORD="master"    //密码

//我们刚才使用 show slaver status 在主数据库查询的信息填到这里
MASTER_LOG_FILE="f08252e11999-bin.000002"  //日志名
MASTER_LOG_POS=313;//

• 查询从节点的状态 
  • SHOW SLAVE STATUS

​​​

• 启动从节点
  • start slave

​​​

• 关闭从节点
  • stop slave

• 安装Redis

• 注意:redis默认启动是没有配置文件的,我们使用自定义配置文件启动
• redis的配置文件

####### Main configuration start #######

#注释掉bind 127.0.0.1，使redis可以外部访问
#bind 127.0.0.1
# 端口号
port 6379

#给redis设置密码
#requirepass red

##redis持久化　　默认是no
appendonly yes

#开启protected-mode保护模式，需配置bind ip或者设置访问密码
#关闭protected-mode模式，此时外部网络可以直接访问
protected-mode no

#是否开启集群
#cluster-enabled no

#集群的配置文件,该文件自动生成
#cluster-config-file nodes.conf

#集群的超时时间
#cluster-node-timeout 5000

#用守护线程的方式启动
daemonize no

#防止出现远程主机强迫关闭了一个现有的连接的错误 默认是300
tcp-keepalive 300

####### Main configuration end #######

timeout 0

tcp-backlog 511

# Note: these supervision methods only signal "process is ready."
#       They do not enable continuous liveness pings back to your supervisor.
supervised no

# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
# Creating a pid file is best effort: if Redis is not able to create it
# nothing bad happens, the server will start and run normally.
pidfile /var/run/redis_6379.pid

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notice

# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
#redis生成的日志(docker容器内的目录,不是宿主机的目录)
logfile ""

# To enable logging to the system logger, just set 'syslog-enabled' to yes,
# and optionally update the other syslog parameters to suit your needs.
# syslog-enabled no

# Specify the syslog identity.
# syslog-ident redis

# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
# syslog-facility local0

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT  where
# dbid is a number between 0 and 'databases'-1
#默认数据库数量
databases 16

# By default Redis shows an ASCII art logo only when started to log to the
# standard output and if the standard output is a TTY. Basically this means
# that normally a logo is displayed only in interactive sessions.
#
# However it is possible to force the pre-4.0 behavior and always show a
# ASCII art logo in startup logs by setting the following option to yes.
always-show-logo yes

################################ SNAPSHOTTING  ################################
#
# Save the DB on disk:
#
#   save  
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving completely by commenting out all "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

# By default Redis will stop accepting writes if RDB snapshots are enabled
# (at least one save point) and the latest background save failed.
# This will make the user aware (in a hard way) that data is not persisting
# on disk properly, otherwise chances are that no one will notice and some
# disaster will happen.
#
# If the background saving process will start working again Redis will
# automatically allow writes again.
#
# However if you have setup your proper monitoring of the Redis server
# and persistence, you may want to disable this feature so that Redis will
# continue to work as usual even if there are problems with disk,
# permissions, and so forth.
stop-writes-on-bgsave-error yes

# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

# Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
# This makes the format more resistant to corruption but there is a performance
# hit to pay (around 10%) when saving and loading RDB files, so you can disable it
# for maximum performances.
#
# RDB files created with checksum disabled have a checksum of zero that will
# tell the loading code to skip the check.
rdbchecksum yes

# The filename where to dump the DB
#rdb持久化生成的默认文件名
dbfilename dump.rdb

# Remove RDB files used by replication in instances without persistence
# enabled. By default this option is disabled, however there are environments
# where for regulations or other security concerns, RDB files persisted on
# disk by masters in order to feed replicas, or stored on disk by replicas
# in order to load them for the initial synchronization, should be deleted
# ASAP. Note that this option ONLY WORKS in instances that have both AOF
# and RDB persistence disabled, otherwise is completely ignored.
#
# An alternative (and sometimes better) way to obtain the same effect is
# to use diskless replication on both master and replicas instances. However
# in the case of replicas, diskless is not always an option.
rdb-del-sync-files no

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir ./


# When a replica loses its connection with the master, or when the replication
# is still in progress, the replica can act in two different ways:
#
# 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will
#    still reply to client requests, possibly with out of date data, or the
#    data set may just be empty if this is the first synchronization.
#
# 2) if replica-serve-stale-data is set to 'no' the replica will reply with
#    an error "SYNC with master in progress" to all the kind of commands
#    but to INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG,
#    SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB,
#    COMMAND, POST, HOST: and LATENCY.
#
replica-serve-stale-data yes

# You can configure a replica instance to accept writes or not. Writing against
# a replica instance may be useful to store some ephemeral data (because data
# written on a replica will be easily deleted after resync with the master) but
# may also cause problems if clients are writing to it because of a
# misconfiguration.
#
# Since Redis 2.6 by default replicas are read-only.
#
# Note: read only replicas are not designed to be exposed to untrusted clients
# on the internet. It's just a protection layer against misuse of the instance.
# Still a read only replica exports by default all the administrative commands
# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
# security of read only replicas using 'rename-command' to shadow all the
# administrative / dangerous commands.
replica-read-only yes


# When diskless replication is used, the master waits a configurable amount of
# time (in seconds) before starting the transfer in the hope that multiple
# replicas will arrive and the transfer can be parallelized.
#
# With slow disks and fast (large bandwidth) networks, diskless replication
# works better.
repl-diskless-sync no

# When diskless replication is enabled, it is possible to configure the delay
# the server waits in order to spawn the child that transfers the RDB via socket
# to the replicas.
#
# This is important since once the transfer starts, it is not possible to serve
# new replicas arriving, that will be queued for the next RDB transfer, so the
# server waits a delay in order to let more replicas arrive.
#
# The delay is specified in seconds, and by default is 5 seconds. To disable
# it entirely just set it to 0 seconds and the transfer will start ASAP.
repl-diskless-sync-delay 5


# In many cases the disk is slower than the network, and storing and loading
# the RDB file may increase replication time (and even increase the master's
# Copy on Write memory and salve buffers).
# However, parsing the RDB file directly from the socket may mean that we have
# to flush the contents of the current database before the full rdb was
# received. For this reason we have the following options:
#
# "disabled"    - Don't use diskless load (store the rdb file to the disk first)
# "on-empty-db" - Use diskless load only when it is completely safe.
# "swapdb"      - Keep a copy of the current db contents in RAM while parsing
#                 the data directly from the socket. note that this requires
#                 sufficient memory, if you don't have it, you risk an OOM kill.
repl-diskless-load disabled


# Disable TCP_NODELAY on the replica socket after SYNC?
#
# If you select "yes" Redis will use a smaller number of TCP packets and
# less bandwidth to send data to replicas. But this can add a delay for
# the data to appear on the replica side, up to 40 milliseconds with
# Linux kernels using a default configuration.
#
# If you select "no" the delay for data to appear on the replica side will
# be reduced but more bandwidth will be used for replication.
#
# By default we optimize for low latency, but in very high traffic conditions
# or when the master and replicas are many hops away, turning this to "yes" may
# be a good idea.
repl-disable-tcp-nodelay no


# The replica priority is an integer number published by Redis in the INFO
# output. It is used by Redis Sentinel in order to select a replica to promote
# into a master if the master is no longer working correctly.
#
# A replica with a low priority number is considered better for promotion, so
# for instance if there are three replicas with priority 10, 100, 25 Sentinel
# will pick the one with priority 10, that is the lowest.
#
# However a special priority of 0 marks the replica as not able to perform the
# role of master, so a replica with priority of 0 will never be selected by
# Redis Sentinel for promotion.
#
# By default the priority is 100.
replica-priority 100


# ACL LOG
#
# The ACL Log tracks failed commands and authentication events associated
# with ACLs. The ACL Log is useful to troubleshoot failed commands blocked
# by ACLs. The ACL Log is stored in memory. You can reclaim memory with
# ACL LOG RESET. Define the maximum entry length of the ACL Log below.
acllog-max-len 128

# Using an external ACL file
#
# Instead of configuring users here in this file, it is possible to use
# a stand-alone file just listing users. The two methods cannot be mixed:
# if you configure users here and at the same time you activate the exteranl
# ACL file, the server will refuse to start.
#
# The format of the external ACL user file is exactly the same as the
# format that is used inside redis.conf to describe users.
#
# aclfile /etc/redis/users.acl


# Command renaming (DEPRECATED).
#
# ------------------------------------------------------------------------
# WARNING: avoid using this option if possible. Instead use ACLs to remove
# commands from the default user, and put them only in some admin user you
# create for administrative purposes.
# ------------------------------------------------------------------------
#
# It is possible to change the name of dangerous commands in a shared
# environment. For instance the CONFIG command may be renamed into something
# hard to guess so that it will still be available for internal-use tools
# but not available for general clients.
#
# Example:
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# It is also possible to completely kill a command by renaming it into
# an empty string:
#
# rename-command CONFIG ""
#
# Please note that changing the name of commands that are logged into the
# AOF file or transmitted to replicas may cause problems.

################################### CLIENTS ####################################

# Set the max number of connected clients at the same time. By default
# this limit is set to 10000 clients, however if the Redis server is not
# able to configure the process file limit to allow for the specified limit
# the max number of allowed clients is set to the current file limit
# minus 32 (as Redis reserves a few file descriptors for internal uses).
#
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#
# IMPORTANT: When Redis Cluster is used, the max number of connections is also
# shared with the cluster bus: every node in the cluster will use two
# connections, one incoming and another outgoing. It is important to size the
# limit accordingly in case of very large clusters.
#
# maxclients 10000

############################## MEMORY MANAGEMENT ################################

# Set a memory usage limit to the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys
# according to the eviction policy selected (see maxmemory-policy).
#
# If Redis can't remove keys according to the policy, or if the policy is
# set to 'noeviction', Redis will start to reply with errors to commands
# that would use more memory, like SET, LPUSH, and so on, and will continue
# to reply to read-only commands like GET.
#
# This option is usually useful when using Redis as an LRU or LFU cache, or to
# set a hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have replicas attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the replicas are subtracted
# from the used memory count, so that network problems / resyncs will
# not trigger a loop where keys are evicted, and in turn the output
# buffer of replicas is full with DELs of keys evicted triggering the deletion
# of more keys, and so forth until the database is completely emptied.
#
# In short... if you have replicas attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for replica
# output buffers (but this is not needed if the policy is 'noeviction').
#redis可以占用的内存 单位字节
# maxmemory 

# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
# is reached. You can select one from the following behaviors:
#
# volatile-lru -> Evict using approximated LRU, only keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key having an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.
#
# LRU means Least Recently Used
# LFU means Least Frequently Used
#
# Both LRU, LFU and volatile-ttl are implemented using approximated
# randomized algorithms.
#
# Note: with any of the above policies, Redis will return an error on write
#       operations, when there are no suitable keys for eviction.
#
#       At the date of writing these commands are: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort
#
# The default is:
# redis过期key的移除策略
# maxmemory-policy noeviction

# LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
# algorithms (in order to save memory), so you can tune it for speed or
# accuracy. For default Redis will check five keys and pick the one that was
# used less recently, you can change the sample size using the following
# configuration directive.
#
# The default of 5 produces good enough results. 10 Approximates very closely
# true LRU but costs more CPU. 3 is faster but not very accurate.
#
# maxmemory-samples 5

# Starting from Redis 5, by default a replica will ignore its maxmemory setting
# (unless it is promoted to master after a failover or manually). It means
# that the eviction of keys will be just handled by the master, sending the
# DEL commands to the replica as keys evict in the master side.
#
# This behavior ensures that masters and replicas stay consistent, and is usually
# what you want, however if your replica is writable, or you want the replica
# to have a different memory setting, and you are sure all the writes performed
# to the replica are idempotent, then you may change this default (but be sure
# to understand what you are doing).
#
# Note that since the replica by default does not evict, it may end using more
# memory than the one set via maxmemory (there are certain buffers that may
# be larger on the replica, or data structures may sometimes take more memory
# and so forth). So make sure you monitor your replicas and make sure they
# have enough memory to never hit a real out-of-memory condition before the
# master hits the configured maxmemory setting.
#
# replica-ignore-maxmemory yes

# Redis reclaims expired keys in two ways: upon access when those keys are
# found to be expired, and also in background, in what is called the
# "active expire key". The key space is slowly and interactively scanned
# looking for expired keys to reclaim, so that it is possible to free memory
# of keys that are expired and will never be accessed again in a short time.
#
# The default effort of the expire cycle will try to avoid having more than
# ten percent of expired keys still in memory, and will try to avoid consuming
# more than 25% of total memory and to add latency to the system. However
# it is possible to increase the expire "effort" that is normally set to
# "1", to a greater value, up to the value "10". At its maximum value the
# system will use more CPU, longer cycles (and technically may introduce
# more latency), and will tollerate less already expired keys still present
# in the system. It's a tradeoff betweeen memory, CPU and latecy.
#
# active-expire-effort 1

############################# LAZY FREEING ####################################

# Redis has two primitives to delete keys. One is called DEL and is a blocking
# deletion of the object. It means that the server stops processing new commands
# in order to reclaim all the memory associated with an object in a synchronous
# way. If the key deleted is associated with a small object, the time needed
# in order to execute the DEL command is very small and comparable to most other
# O(1) or O(log_N) commands in Redis. However if the key is associated with an
# aggregated value containing millions of elements, the server can block for
# a long time (even seconds) in order to complete the operation.
#
# For the above reasons Redis also offers non blocking deletion primitives
# such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
# FLUSHDB commands, in order to reclaim memory in background. Those commands
# are executed in constant time. Another thread will incrementally free the
# object in the background as fast as possible.
#
# DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
# It's up to the design of the application to understand when it is a good
# idea to use one or the other. However the Redis server sometimes has to
# delete keys or flush the whole database as a side effect of other operations.
# Specifically Redis deletes objects independently of a user call in the
# following scenarios:
#
# 1) On eviction, because of the maxmemory and maxmemory policy configurations,
#    in order to make room for new data, without going over the specified
#    memory limit.
# 2) Because of expire: when a key with an associated time to live (see the
#    EXPIRE command) must be deleted from memory.
# 3) Because of a side effect of a command that stores data on a key that may
#    already exist. For example the RENAME command may delete the old key
#    content when it is replaced with another one. Similarly SUNIONSTORE
#    or SORT with STORE option may delete existing keys. The SET command
#    itself removes any old content of the specified key in order to replace
#    it with the specified string.
# 4) During replication, when a replica performs a full resynchronization with
#    its master, the content of the whole database is removed in order to
#    load the RDB file just transferred.
#
# In all the above cases the default is to delete objects in a blocking way,
# like if DEL was called. However you can configure each case specifically
# in order to instead release memory in a non-blocking way like if UNLINK
# was called, using the following configuration directives.

lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no

# It is also possible, for the case when to replace the user code DEL calls
# with UNLINK calls is not easy, to modify the default behavior of the DEL
# command to act exactly like UNLINK, using the following configuration
# directive:

lazyfree-lazy-user-del no



# The name of the append only file (default: "appendonly.aof")

appendfilename "appendonly.aof"

# The fsync() call tells the Operating System to actually write data on disk
# instead of waiting for more data in the output buffer. Some OS will really flush
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log. Slow, Safest.
# everysec: fsync only one time every second. Compromise.
#
# The default is "everysec", as that's usually the right compromise between
# speed and data safety. It's up to you to understand if you can relax this to
# "no" that will let the operating system flush the output buffer when
# it wants, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting),
# or on the contrary, use "always" that's very slow but a bit safer than
# everysec.
#
# More details please check the following article:
# http://antirez.com/post/redis-persistence-demystified.html
#
# If unsure, use "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no

# When the AOF fsync policy is set to always or everysec, and a background
# saving process (a background save or AOF log background rewriting) is
# performing a lot of I/O against the disk, in some Linux configurations
# Redis may block too long on the fsync() call. Note that there is no fix for
# this currently, as even performing fsync in a different thread will block
# our synchronous write(2) call.
#
# In order to mitigate this problem it's possible to use the following option
# that will prevent fsync() from being called in the main process while a
# BGSAVE or BGREWRITEAOF is in progress.
#
# This means that while another child is saving, the durability of Redis is
# the same as "appendfsync none". In practical terms, this means that it is
# possible to lose up to 30 seconds of log in the worst scenario (with the
# default Linux settings).
#
# If you have latency problems turn this to "yes". Otherwise leave it as
# "no" that is the safest pick from the point of view of durability.

no-appendfsync-on-rewrite no

# Automatic rewrite of the append only file.
# Redis is able to automatically rewrite the log file implicitly calling
# BGREWRITEAOF when the AOF log size grows by the specified percentage.
#
# This is how it works: Redis remembers the size of the AOF file after the
# latest rewrite (if no rewrite has happened since the restart, the size of
# the AOF at startup is used).
#
# This base size is compared to the current size. If the current size is
# bigger than the specified percentage, the rewrite is triggered. Also
# you need to specify a minimal size for the AOF file to be rewritten, this
# is useful to avoid rewriting the AOF file even if the percentage increase
# is reached but it is still pretty small.
#
# Specify a percentage of zero in order to disable the automatic AOF
# rewrite feature.

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# An AOF file may be found to be truncated at the end during the Redis
# startup process, when the AOF data gets loaded back into memory.
# This may happen when the system where Redis is running
# crashes, especially when an ext4 filesystem is mounted without the
# data=ordered option (however this can't happen when Redis itself
# crashes or aborts but the operating system still works correctly).
#
# Redis can either exit with an error when this happens, or load as much
# data as possible (the default now) and start if the AOF file is found
# to be truncated at the end. The following option controls this behavior.
#
# If aof-load-truncated is set to yes, a truncated AOF file is loaded and
# the Redis server starts emitting a log to inform the user of the event.
# Otherwise if the option is set to no, the server aborts with an error
# and refuses to start. When the option is set to no, the user requires
# to fix the AOF file using the "redis-check-aof" utility before to restart
# the server.
#
# Note that if the AOF file will be found to be corrupted in the middle
# the server will still exit with an error. This option only applies when
# Redis will try to read more data from the AOF file but not enough bytes
# will be found.
aof-load-truncated yes

# When rewriting the AOF file, Redis is able to use an RDB preamble in the
# AOF file for faster rewrites and recoveries. When this option is turned
# on the rewritten AOF file is composed of two different stanzas:
#
#   [RDB file][AOF tail]
#
# When loading Redis recognizes that the AOF file starts with the "REDIS"
# string and loads the prefixed RDB file, and continues loading the AOF
# tail.
aof-use-rdb-preamble yes

################################ LUA SCRIPTING  ###############################

# Max execution time of a Lua script in milliseconds.
#
# If the maximum execution time is reached Redis will log that a script is
# still in execution after the maximum allowed time and will start to
# reply to queries with an error.
#
# When a long running script exceeds the maximum execution time only the
# SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
# used to stop a script that did not yet called write commands. The second
# is the only way to shut down the server in the case a write command was
# already issued by the script but the user doesn't want to wait for the natural
# termination of the script.
#
# Set it to 0 or a negative value for unlimited execution without warnings.
lua-time-limit 5000

################################ REDIS CLUSTER  ###############################

# Normal Redis instances can't be part of a Redis Cluster; only nodes that are
# started as cluster nodes can. In order to start a Redis instance as a
# cluster node enable the cluster support uncommenting the following:
#
# cluster-enabled yes

# Every cluster node has a cluster configuration file. This file is not
# intended to be edited by hand. It is created and updated by Redis nodes.
# Every Redis Cluster node requires a different cluster configuration file.
# Make sure that instances running in the same system do not have
# overlapping cluster configuration file names.
#
# cluster-config-file nodes-6379.conf

# Cluster node timeout is the amount of milliseconds a node must be unreachable
# for it to be considered in failure state.
# Most other internal time limits are multiple of the node timeout.
#
# cluster-node-timeout 15000

# A replica of a failing master will avoid to start a failover if its data
# looks too old.
#
# There is no simple way for a replica to actually have an exact measure of
# its "data age", so the following two checks are performed:
#
# 1) If there are multiple replicas able to failover, they exchange messages
#    in order to try to give an advantage to the replica with the best
#    replication offset (more data from the master processed).
#    Replicas will try to get their rank by offset, and apply to the start
#    of the failover a delay proportional to their rank.
#
# 2) Every single replica computes the time of the last interaction with
#    its master. This can be the last ping or command received (if the master
#    is still in the "connected" state), or the time that elapsed since the
#    disconnection with the master (if the replication link is currently down).
#    If the last interaction is too old, the replica will not try to failover
#    at all.
#
# The point "2" can be tuned by user. Specifically a replica will not perform
# the failover if, since the last interaction with the master, the time
# elapsed is greater than:
#
#   (node-timeout * replica-validity-factor) + repl-ping-replica-period
#
# So for example if node-timeout is 30 seconds, and the replica-validity-factor
# is 10, and assuming a default repl-ping-replica-period of 10 seconds, the
# replica will not try to failover if it was not able to talk with the master
# for longer than 310 seconds.
#
# A large replica-validity-factor may allow replicas with too old data to failover
# a master, while a too small value may prevent the cluster from being able to
# elect a replica at all.
#
# For maximum availability, it is possible to set the replica-validity-factor
# to a value of 0, which means, that replicas will always try to failover the
# master regardless of the last time they interacted with the master.
# (However they'll always try to apply a delay proportional to their
# offset rank).
#
# Zero is the only value able to guarantee that when all the partitions heal
# the cluster will always be able to continue.
#
# cluster-replica-validity-factor 10

# Cluster replicas are able to migrate to orphaned masters, that are masters
# that are left without working replicas. This improves the cluster ability
# to resist to failures as otherwise an orphaned master can't be failed over
# in case of failure if it has no working replicas.
#
# Replicas migrate to orphaned masters only if there are still at least a
# given number of other working replicas for their old master. This number
# is the "migration barrier". A migration barrier of 1 means that a replica
# will migrate only if there is at least 1 other working replica for its master
# and so forth. It usually reflects the number of replicas you want for every
# master in your cluster.
#
# Default is 1 (replicas migrate only if their masters remain with at least
# one replica). To disable migration just set it to a very large value.
# A value of 0 can be set but is useful only for debugging and dangerous
# in production.
#
# cluster-migration-barrier 1

# By default Redis Cluster nodes stop accepting queries if they detect there
# is at least an hash slot uncovered (no available node is serving it).
# This way if the cluster is partially down (for example a range of hash slots
# are no longer covered) all the cluster becomes, eventually, unavailable.
# It automatically returns available as soon as all the slots are covered again.
#
# However sometimes you want the subset of the cluster which is working,
# to continue to accept queries for the part of the key space that is still
# covered. In order to do so, just set the cluster-require-full-coverage
# option to no.
#
# cluster-require-full-coverage yes

# This option, when set to yes, prevents replicas from trying to failover its
# master during master failures. However the master can still perform a
# manual failover, if forced to do so.
#
# This is useful in different scenarios, especially in the case of multiple
# data center operations, where we want one side to never be promoted if not
# in the case of a total DC failure.
#
# cluster-replica-no-failover no

# This option, when set to yes, allows nodes to serve read traffic while the
# the cluster is in a down state, as long as it believes it owns the slots.
#
# This is useful for two cases.  The first case is for when an application
# doesn't require consistency of data during node failures or network partitions.
# One example of this is a cache, where as long as the node has the data it
# should be able to serve it.
#
# The second use case is for configurations that don't meet the recommended
# three shards but want to enable cluster mode and scale later. A
# master outage in a 1 or 2 shard configuration causes a read/write outage to the
# entire cluster without this option set, with it set there is only a write outage.
# Without a quorum of masters, slot ownership will not change automatically.
#
# cluster-allow-reads-when-down no

# In order to setup your cluster make sure to read the documentation
# available at http://redis.io web site.

########################## CLUSTER DOCKER/NAT support  ########################

# In certain deployments, Redis Cluster nodes address discovery fails, because
# addresses are NAT-ted or because ports are forwarded (the typical case is
# Docker and other containers).
#
# In order to make Redis Cluster working in such environments, a static
# configuration where each node knows its public address is needed. The
# following two options are used for this scope, and are:
#
# * cluster-announce-ip
# * cluster-announce-port
# * cluster-announce-bus-port
#
# Each instruct the node about its address, client port, and cluster message
# bus port. The information is then published in the header of the bus packets
# so that other nodes will be able to correctly map the address of the node
# publishing the information.
#
# If the above options are not used, the normal Redis Cluster auto-detection
# will be used instead.
#
# Note that when remapped, the bus port may not be at the fixed offset of
# clients port + 10000, so you can specify any port and bus-port depending
# on how they get remapped. If the bus-port is not set, a fixed offset of
# 10000 will be used as usually.
#
# Example:
#
# cluster-announce-ip 10.1.1.5
# cluster-announce-port 6379
# cluster-announce-bus-port 6380

################################## SLOW LOG ###################################

# The Redis Slow Log is a system to log queries that exceeded a specified
# execution time. The execution time does not include the I/O operations
# like talking with the client, sending the reply and so forth,
# but just the time needed to actually execute the command (this is the only
# stage of command execution where the thread is blocked and can not serve
# other requests in the meantime).
#
# You can configure the slow log with two parameters: one tells Redis
# what is the execution time, in microseconds, to exceed in order for the
# command to get logged, and the other parameter is the length of the
# slow log. When a new command is logged the oldest one is removed from the
# queue of logged commands.

# The following time is expressed in microseconds, so 1000000 is equivalent
# to one second. Note that a negative number disables the slow log, while
# a value of zero forces the logging of every command.
slowlog-log-slower-than 10000

# There is no limit to this length. Just be aware that it will consume memory.
# You can reclaim memory used by the slow log with SLOWLOG RESET.
slowlog-max-len 128


# By default latency monitoring is disabled since it is mostly not needed
# if you don't have latency issues, and collecting data has a performance
# impact, that while very small, can be measured under big load. Latency
# monitoring can easily be enabled at runtime using the command
# "CONFIG SET latency-monitor-threshold " if needed.
latency-monitor-threshold 0

#  By default all notifications are disabled because most users don't need
#  this feature and the feature has some overhead. Note that if you don't
#  specify at least one of K or E, no events will be delivered.
notify-keyspace-events ""



############################### ADVANCED CONFIG ###############################

# Hashes are encoded using a memory efficient data structure when they have a
# small number of entries, and the biggest entry does not exceed a given
# threshold. These thresholds can be configured using the following directives.
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# Lists are also encoded in a special way to save a lot of space.
# The number of entries allowed per internal list node can be specified
# as a fixed maximum size or a maximum number of elements.
# For a fixed maximum size, use -5 through -1, meaning:
# -5: max size: 64 Kb  <-- not recommended for normal workloads
# -4: max size: 32 Kb  <-- not recommended
# -3: max size: 16 Kb  <-- probably not recommended
# -2: max size: 8 Kb   <-- good
# -1: max size: 4 Kb   <-- good
# Positive numbers mean store up to _exactly_ that number of elements
# per list node.
# The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
# but if your use case is unique, adjust the settings as necessary.
list-max-ziplist-size -2

# Lists may also be compressed.
# Compress depth is the number of quicklist ziplist nodes from *each* side of
# the list to *exclude* from compression.  The head and tail of the list
# are always uncompressed for fast push/pop operations.  Settings are:
# 0: disable all list compression
# 1: depth 1 means "don't start compressing until after 1 node into the list,
#    going from either the head or tail"
#    So: [head]->node->node->...->node->[tail]
#    [head], [tail] will always be uncompressed; inner nodes will compress.
# 2: [head]->[next]->node->node->...->node->[prev]->[tail]
#    2 here means: don't compress head or head->next or tail->prev or tail,
#    but compress all nodes between them.
# 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
# etc.
list-compress-depth 0

# Sets have a special encoding in just one case: when a set is composed
# of just strings that happen to be integers in radix 10 in the range
# of 64 bit signed integers.
# The following configuration setting sets the limit in the size of the
# set in order to use this special memory saving encoding.
set-max-intset-entries 512

# Similarly to hashes and lists, sorted sets are also specially encoded in
# order to save a lot of space. This encoding is only used when the length and
# elements of a sorted set are below the following limits:
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# The suggested value is ~ 3000 in order to have the benefits of
# the space efficient encoding without slowing down too much PFADD,
# which is O(N) with the sparse encoding. The value can be raised to
# ~ 10000 when CPU is not a concern, but space is, and the data set is
# composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
hll-sparse-max-bytes 3000

# Streams macro node max size / items. The stream data structure is a radix
# tree of big nodes that encode multiple items inside. Using this configuration
# it is possible to configure how big a single node can be in bytes, and the
# maximum number of items it may contain before switching to a new node when
# appending new stream entries. If any of the following settings are set to
# zero, the limit is ignored, so for instance it is possible to set just a
# max entires limit by setting max-bytes to 0 and max-entries to the desired
# value.
stream-node-max-bytes 4096
stream-node-max-entries 100


# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
activerehashing yes


# Instead there is a default limit for pubsub and replica clients, since
# subscribers and replicas receive data in a push fashion.
#
# Both the hard or the soft limit can be disabled by setting them to zero.
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

# Client query buffers accumulate new commands. They are limited to a fixed
# amount by default in order to avoid that a protocol desynchronization (for
# instance due to a bug in the client) will lead to unbound memory usage in
# the query buffer. However you can configure it here if you have very special
# needs, such us huge multi/exec requests or alike.
#
# client-query-buffer-limit 1gb

# In the Redis protocol, bulk requests, that are, elements representing single
# strings, are normally limited ot 512 mb. However you can change this limit
# here.
#
# proto-max-bulk-len 512mb


# The range is between 1 and 500, however a value over 100 is usually not
# a good idea. Most users should use the default of 10 and raise this up to
# 100 only in environments where very low latency is required.
hz 10


# When dynamic HZ is enabled, the actual configured HZ will be used
# as a baseline, but multiples of the configured HZ value will be actually
# used as needed once more clients are connected. In this way an idle
# instance will use very little CPU time while a busy instance will be
# more responsive.
dynamic-hz yes

# When a child rewrites the AOF file, if the following option is enabled
# the file will be fsync-ed every 32 MB of data generated. This is useful
# in order to commit the file to the disk more incrementally and avoid
# big latency spikes.
aof-rewrite-incremental-fsync yes

# When redis saves RDB file, if the following option is enabled
# the file will be fsync-ed every 32 MB of data generated. This is useful
# in order to commit the file to the disk more incrementally and avoid
# big latency spikes.
rdb-save-incremental-fsync yes



# Jemalloc background thread for purging will be enabled by default
jemalloc-bg-thread yes

//拉取镜像
docker pull redis:6.0.15

//在宿主机的root目录下创建文件夹将redis的配置文件复制进去
vi /root/redis/redis.conf

//设置文件内权限
chmod 777 /root/redis/redis.conf

//运行镜像 redis-master ,斜杠 \ 表示换行
docker run --name redis-master -p 6379:6379 \
-v /root/redis/redis.conf:/data/redis.conf  \
-d redis:6.0.15 redis-server /data/redis.conf

//运行镜像  redis-slaver
docker run --name redis-slaver -p 6380:6379  \
-v /root/redis/redis.conf:/data/redis.conf  \
-d redis:6.0.15 redis-server /data/redis.conf

• 设置Redis主从（启动单机版Redis可以不做这一步）

//进入redis-master容器
docker exec -it redis-master /bin/bash

//链接redis
redis-cli

//查看redis状态 
info replication


//redis-master 查询结果
# Replication
role:master        //当前redis是主节点
connected_slaves:0    //自己下面有0个子节点
master_replid:88935387dfc7d6ae915ae14b809439b0fc195044
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0


//redis-slaver 查询结果
# Replication
role:master        //当前redis是主节点
connected_slaves:0    //自己下面有0个子节点
master_replid:88935387dfc7d6ae915ae14b809439b0fc195044
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

• 发现redis-master 和 redis-slaver  都是主节点,接下来设置redsi-slaver为从节点
     

//进入redis-slaver 容器内部
docker exec -it redis-slaver /bin/bash

//链接redis
redis-cli

//设置主节点的端口和IP
slaveof 82.159.190.100 6379

//再进入reids-mster 内查看，发现当前已经有了一个子节点 
127.0.0.1:6379> INFO replication
# Replication
role:master            //当前 是 master
connected_slaves:1  //一个子节点
slave0:ip=82.156.190.100,port=6379,state=online,offset=140,lag=0
master_replid:ce704c63df0857208b616e60d186e14890141ef3
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:140
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:140

Redis配置哨兵(一主一从一哨兵) 

遇到的坑(注意一下几点):

1. 配置哨兵一定要开启redis的持久化(RDB 或者 AOF).
2. 与持久化有关的文件,一定要有所有用户可读写权限,容器内部和外部挂载文件都要给权限. 拿下面的图片举例 dump.db 文件.
3. 设置权限的命令 : chmod  777  dump.db
4. 
5. redis.conf 配置文件也要赋予所有用户可读写权限.(所有主和从都需要配)
6. 注意暴露 主节点, 从节点, 哨兵 的端口
7. 如果redis直接启动(直接启动默认没有redis.conf配置文件),会导致哨兵启动后,master节点变成了slave.并且无master节点,全是slave.

//在宿主机的root目录下创建文件将sentinel的配置文件复制进去
vi /root/redis/sentinel.conf

/*-----------------------sentinel.conf的配置文件----------------
#哨兵的端口 默认就是这个端口
port 26379  

#生成的日志(容器的目录)
logfile "/data/sentinel.log"

# rmaster 表示自定义的master名 , 后面是master节点的IP 和端口 , 
# 最后的1 表示只要有一个哨兵投票,即可将slave升级成master
sentinel monitor rmaster 192.168.100.10 6379 1

-----------------------------------配置文件结束 ---------------------*/

//启动哨兵
docker --name redis_sentinel -p 26379:26379 \
-v /root/redis/sentinel.conf:/data/sentinel.conf \
-v /root/redis/sentinel.log:/data/sentinel.log \
-d redis:6.0.15 redis-sentinel /data/sentinel.conf

 安装mongoDB

//拉取镜像
docker pull mongo:5.0.3

//运行
docker run --name mongo -p 27017:27017  \
-v /usr/local/docker/mongodb/data:/data/db  \
-e MONGO_INITDB_ROOT_USERNAME=root  \
-e MONGO_INITDB_ROOT_PASSWORD=root  \
-d mongo:5.0.3

mongoDB视图工具

链接：mongo视图工具
提取码：dw7d 
--来自百度网盘超级会员V3的分享

第一步：

运行：MongoDBCompass.exe

第二步：

安装RocketMQ

//安装rocketMQ NameServer
docker pull rocketmqinc/rocketmq-namesrv:4.5.0-alpine
docker run --name rmqsrv -d -p 9876:9876 rocketmqinc/rocketmq-namesrv:4.5.0-alpine



//拉取RocketMQ Broker镜像
docker pull rocketmqinc/rocketmq-broker:4.5.0-alpine

//编写broker的配置文件
 vi /root/rmq/broker.conf

//复制一下内容,到broker.conf文件中
# 所属集群名称，如果节点较多可以配置多个
brokerClusterName = DefaultCluster
#broker名称，master和slave使用相同的名称，表明他们的主从关系
brokerName = broker-a
#0表示Master，大于0表示不同的slave
brokerId = 0
#表示几点做消息删除动作，默认是凌晨4点
deleteWhen = 04
#在磁盘上保留消息的时长，单位是小时
fileReservedTime = 48
#有三个值：SYNC_MASTER，ASYNC_MASTER，SLAVE；同步和异步表示Master和Slave之间同步数据的机制；
brokerRole = ASYNC_MASTER
#刷盘策略，取值为：ASYNC_FLUSH，SYNC_FLUSH表示同步刷盘和异步刷盘；SYNC_FLUSH消息写入磁盘后才返回成功状态，ASYNC_FLUSH不需要；
flushDiskType = ASYNC_FLUSH
#设置broker节点所在服务器的ip地址
brokerIP1 = 192.168.52.136
#指定Name Server的地址
namesrvAddr=192.168.17.129:9876;192.168.17.130:9876



//启动容器RocketMQ Broker
docker run --name rmqbroker  -p 10909:10909 -p 10911:10911 \
--link rmqsrv:rmqsrv  \
-e "NAMESRV_ADDR=rmqsrv:9876" -e "MAX_POSSIBLE_HEAP=200000000"  \
-v /root/rmq/broker.conf:/opt/rocketmq-4.5.0/conf/broker.conf  \
-d  rocketmqinc/rocketmq-broker:4.5.0-alpine \
sh mqbroker -c /opt/rocketmq-4.5.0/conf/broker.conf 




//安装Rocket Console ，这是RocketMQ的一个视图工具
docker pull styletang/rocketmq-console-ng:1.0.0
//启动视图工具
docker run --name rmqconsole -p 8889:8080 --link rmqsrv:rmqsrv \
-e "JAVA_OPTS=-Drocketmq.namesrv.addr=rmqsrv:9876  \
-Dcom.rocketmq.sendMessageWithVIPChannel=false"  \
-d styletang/rocketmq-console-ng:1.0.0 

/** 
安装完成，接下来打开浏览器访问rocketMQ的试图工具查看，主题、集群、消费者等是否有数据，无数据先查看，rocketMQ NameServer 和broker是否启动，在查看，Name Server和Broker是否链接 。
**/