linux安装docker和redis和rabbitmq和nginx和rocketmq和kafka

1.1系统要求
内存    4GB    8GB+
CPU   2核      4核+
磁盘   20GB  50GB+

关闭防火墙（可选）# CentOS/RHEL
systemctl stop firewalld
systemctl disable firewalld

# Ubuntu/Debian
ufw disable1.3 关闭 SELinux（可选）
setenforce 0
sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

 卸载旧版本（如果存在）
# CentOS/RHEL
yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

# Ubuntu/Debian
apt-get remove docker docker-engine docker.io containerd runc

安装依赖包
# CentOS/RHEL
yum install -y yum-utils device-mapper-persistent-data lvm2

# Ubuntu/Debian
apt-get update && apt-get install -y ca-certificates curl gnupg lsb-release


官方源（国外，可能较慢）# CentOS/RHEL
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# Ubuntu/Debian
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/trusted.gpg.d/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

2.3.2 国内镜像源（推荐）CentOS/RHEL 
- 使用阿里云镜像源：yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repoCentOS/RHEL
- 使用中科大镜像源：yum-config-manager --add-repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo

Ubuntu/Debian 
- 使用阿里云镜像源：curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/trusted.gpg.d/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/docker.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/nullUbuntu/Debian

 - 使用中科大镜像源：curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/trusted.gpg.d/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/docker.gpg] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null



镜像源CentOS/RHEL 地址                                                                                                  Ubuntu/Debian 地址
阿里云https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo                https://mirrors.aliyun.com/docker-ce/linux/ubuntu

中科大https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo                https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu

清华https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/docker-ce.repo   https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu

华为云https://repo.huaweicloud.com/docker-ce/linux/centos/docker-ce.repo          https://repo.huaweicloud.com/docker-ce/linux/ubuntu

腾讯云https://mirrors.cloud.tencent.com/docker-ce/linux/centos/docker-ce.repo    https://mirrors.cloud.tencent.com/docker-ce/linux/ubuntu

2.4 安装 Docker CE
# CentOS/RHEL
yum install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Ubuntu/Debian
apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

安装包说明：
docker-ceDocker 引擎，核心组件，负责容器的创建、运行和管理
docker-ce-cliDocker 命令行工具，提供 docker 命令接口
containerd.io容器运行时，负责管理容器生命周期
docker-compose-pluginDocker Compose v2 插件，提供 docker compose 命令


启动 Docker 服务
systemctl start docker
systemctl enable docker

2.6 验证安装docker --version
docker compose version

2.7 配置镜像加速器（推荐）
2.7.1 常用国内镜像加速器列表镜像源地址说明Docker
 中国https://registry.docker-cn.com               Docker 官方中国镜像（已停止维护）

DaoCloudhttps://docker.m.daocloud.io  道客云加速器，速度快

网易https://hub-mirror.c.163.com    网易镜像站，稳定可靠

百度https://mirror.baidubce.com百度智能云镜像阿里云https://<你的阿里云ID>.mirror.aliyuncs.com   需要阿里云账号

中科大https://docker.mirrors.ustc.edu.cn    中国科学技术大学镜像

清华https://mirrors.tuna.tsinghua.edu.cn/docker Hub   清华大学镜像

华为云https://hub.mirror.kce.华为云.com   华为云镜像

腾讯云https://mirror.ccs.tencentyun.com   腾讯云镜像

七牛云https://reg-mirror.qiniu.com    七牛云镜像

2.7.2 配置镜像加速器（多源方案）
mkdir -p /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
    "registry-mirrors": [
        "https://docker.m.daocloud.io",
        "https://hub-mirror.c.163.com",
        "https://mirror.baidubce.com",
        "https://docker.mirrors.ustc.edu.cn",
        "https://reg-mirror.qiniu.com"
    ]
}
EOF
systemctl daemon-reload
systemctl restart docker

2.7.3 验证镜像加速器配置# 重启后验证配置
docker info | grep -A 5 "Registry Mirrors"

# 测试拉取速度
time docker pull mysql:5.7

镜像源不可达时的解决方案
方案一：更换镜像源# 修改 daemon.json，替换为可用的镜像源
cat > /etc/docker/daemon.json <<EOF
{
    "registry-mirrors": [
        "https://新的镜像源地址1",
        "https://新的镜像源地址2"
    ]
}
EOF
systemctl daemon-reload
systemctl restart docker

方案二：直接从特定镜像源拉取# 从 DaoCloud 拉取
docker pull docker.m.daocloud.io/library/mysql:5.7

# 从中科大拉取
docker pull docker.mirrors.ustc.edu.cn/library/mysql:5.7

# 从网易拉取
docker pull hub-mirror.c.163.com/library/mysql:5.7

# 重新打标签
docker tag docker.m.daocloud.io/library/mysql:5.7 mysql:5.7

方案三：配置 systemd 代理（适用于网络受限环境）# 创建 systemd 服务目录
mkdir -p /etc/systemd/system/docker.service.d

# 创建 http-proxy.conf
cat > /etc/systemd/system/docker.service.d/http-proxy.conf <<EOF
[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080/"
Environment="HTTPS_PROXY=https://proxy.example.com:8080/"
Environment="NO_PROXY=localhost,127.0.0.1,docker-registry.example.com,.example.com"
EOF

# 重新加载 systemd
systemctl daemon-reload
systemctl restart docker

# 验证代理配置
docker info | grep -i proxy

方案四：手动下载镜像并导入# 在有网络的机器上下载
docker pull mysql:5.7
docker save mysql:5.7 > mysql-5.7.tar

# 传输到目标机器后导入
docker load < mysql-5.7.tar

 镜像源优先级说明Docker 会按照 registry-mirrors 列表的顺序依次尝试拉取镜像，建议将最稳定、速度最快的镜像源放在前面。如果某个镜像源不可达，Docker 会自动尝试下一个。
2.7.6 常见镜像源问题排查# 测试镜像源连通性
curl -I https://docker.m.daocloud.io/v2/
curl -I https://hub-mirror.c.163.com/v2/

# 检查 DNS 解析
nslookup docker.m.daocloud.io

# 检查防火墙
firewall-cmd --list-ports
iptables -L INPUT

# 检查 SELinux
getenforce

# 查看 Docker 日志
journalctl -u docker -f

部署 MySQL3.2.1.1 
创建数据目录
mkdir -p /data/docker/mysql/{conf,data,logs}

3.2.1.2 创建 MySQL 配置文件
cat > /data/docker/mysql/conf/my.cnf <<EOF
[mysqld]
user=mysql
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
default-time-zone=+8:00
max_connections=1000
wait_timeout=28800
interactive_timeout=28800
query_cache_type=0
query_cache_size=0
lower_case_table_names=1
EOF

3.2.1.3 使用 Docker 启动 MySQL
docker run -d \
    --name mysql \
    --restart=always \
    -p 60001:3306 \
    -v /data/docker/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf \
    -v /data/docker/mysql/data:/var/lib/mysql \
    -v /data/docker/mysql/logs:/logs \
    -e MYSQL_ROOT_PASSWORD=password123 \
    mysql:5.7

验证 MySQL 安装
docker exec -it mysql mysql -uroot -ppassword123

部署 Redis
3.2.2.1 创建数据目录
mkdir -p /data/docker/redis/{conf,data}

3.2.2.2 创建 Redis 配置文件
cat > /data/docker/redis/conf/redis.conf <<EOF
bind 0.0.0.0
protected-mode no
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 16
always-show-logo yes
save 900 1
save 300 10
save 600 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
requirepass password123
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 600
client-output-buffer-limit pubsub 32mb 8mb 600
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
EOF

3.2.2.3 使用 Docker 启动 Redis
docker run -d \
    --name redis \
    --restart=always \
    -p 60002:6379 \
    -v /data/docker/redis/conf/redis.conf:/etc/redis/redis.conf \
    -v /data/docker/redis/data:/data \
    redis:6.2 redis-server /etc/redis/redis.conf

验证 Redis 安装
docker exec -it redis redis-cli -a password123

3.2.3 部署 Nacos
3.2.3.1 创建数据目录
mkdir -p /data/docker/nacos/{conf,data,logs}

3.2.3.2 创建 Nacos 配置文件
cat > /data/docker/nacos/conf/application.properties <<EOF
server.servlet.contextPath=/nacos
server.port=8848

spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://mysql:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
db.user=root
db.password=password123

nacos.core.auth.system.type=nacos
nacos.core.auth.enabled=true
nacos.core.auth.server.identity.key=nacos
nacos.core.auth.server.identity.value=nacos
nacos.core.auth.plugin.nacos.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789012345

nacos.core.auth.caching.enabled=true
EOF

3.2.3.3 初始化 Nacos 数据库
docker exec -it mysql mysql -uroot -ppassword123 -e "CREATE DATABASE IF NOT EXISTS nacos_config CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;"

3.2.3.4 使用 Docker 启动 Nacos
docker run -d \
    --name nacos \
    --restart=always \
    --link mysql:mysql \
    -p 60003:8848 \
    -p 9848:9848 \
    -p 9849:9849 \
    -v /data/docker/nacos/conf/application.properties:/home/nacos/conf/application.properties \
    -v /data/docker/nacos/data:/home/nacos/data \
    -v /data/docker/nacos/logs:/home/nacos/logs \
    -e MODE=standalone \
    -e NACOS_SERVER_PORT=8848 \
    -e PREFER_HOST_MODE=hostname \
    nacos/nacos-server:v3.0.2

验证 Nacos 安装访问 Web 管理界面：
http://服务器IP:8848/nacos
默认账号密码：nacos / nacos

3.2.4 部署 RabbitMQ
3.2.4.1 创建数据目录
mkdir -p /data/docker/rabbitmq/{conf,data,logs}

3.2.4.2 使用 Docker 启动 RabbitMQ
docker run -d \
    --name rabbitmq \
    --restart=always \
    -p 60004:5672 \
    -p 60005:15672 \
    -v /data/docker/rabbitmq/data:/var/lib/rabbitmq \
    -v /data/docker/rabbitmq/logs:/var/log/rabbitmq \
    -e RABBITMQ_DEFAULT_USER=admin \
    -e RABBITMQ_DEFAULT_PASS=password123 \
    rabbitmq:3.12-management

验证 RabbitMQ 安装访问 Web 管理界面：
http://服务器IP:15672
默认账号密码：admin / password123

3.2.5 部署 RocketMQ
3.2.5.1 创建数据目录
mkdir -p /data/docker/rocketmq/{namesrv/data,broker/data,broker/logs,console/logs}

3.2.5.2 启动 NameServer
docker run -d \
    --name rmqnamesrv \
    --restart=always \
    -p 60006:9876 \
    -v /data/docker/rocketmq/namesrv/data:/root/store \
    -e MAX_POSSIBLE_HEAP=1024m \
    apache/rocketmq:4.9.5 \
    sh mqnamesrv

3.2.5.3 启动 Broker
docker run -d \
    --name rmqbroker \
    --restart=always \
    --link rmqnamesrv:rmqnamesrv \
    -p 10911:10911 \
    -p 10909:10909 \
    -v /data/docker/rocketmq/broker/data:/root/store \
    -v /data/docker/rocketmq/broker/logs:/root/logs \
    -e NAMESRV_ADDR=rmqnamesrv:9876 \
    -e MAX_POSSIBLE_HEAP=2048m \
    apache/rocketmq:4.9.5 \
    sh mqbroker -c /etc/rocketmq/broker.conf

3.2.5.4 启动 RocketMQ Console
docker run -d \
    --name rmqconsole \
    --restart=always \
    --link rmqnamesrv:rmqnamesrv \
    -p 60007:8080 \
    -e NAMESRV_ADDR=rmqnamesrv:9876 \
    styletang/rocketmq-console-ng:2.0.0

验证 RocketMQ 安装访问 Console 管理界面：
http://服务器IP:8080

3.2.6 部署 Kafka
3.2.6.1 创建数据目录
mkdir -p /data/docker/kafka/{zookeeper/data,zookeeper/logs,kafka/data,kafka/logs}

3.2.6.2 启动 ZooKeeper
docker run -d \
    --name zookeeper \
    --restart=always \
    -p 60008:2181 \
    -v /data/docker/kafka/zookeeper/data:/data \
    -v /data/docker/kafka/zookeeper/logs:/datalog \
    -e ZOO_MY_ID=1 \
    -e ZOO_SERVERS=server.1=0.0.0.0:2888:3888;2181 \
    zookeeper:3.8

3.2.6.3 启动 Kafka
docker run -d \
    --name kafka \
    --restart=always \
    --link zookeeper:zookeeper \
    -p 9092:9092 \
    -p 60009:9093 \
    -v /data/docker/kafka/kafka/data:/kafka/data \
    -e KAFKA_BROKER_ID=1 \
    -e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 \
    -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092,PLAINTEXT_HOST://服务器IP:9093 \
    -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092,PLAINTEXT_HOST://0.0.0.0:9093 \
    -e KAFKA_LISTENER_SECURITY_PROTOCOL_MAP=PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT \
    -e KAFKA_INTER_BROKER_LISTENER_NAME=PLAINTEXT \
    -e KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR=1 \
    wurstmeister/kafka:2.13-2.8.1

验证 Kafka 安装# 方式一：容器内部使用服务名访问
docker exec -it kafka bash
kafka-topics.sh --create --topic test-topic --bootstrap-server kafka:9092 --partitions 1 --replication-factor 1

# 方式二：宿主机使用 IP 访问
kafka-topics.sh --list --bootstrap-server 服务器IP:90933.2.6.6 验证 Kafka 消息收发# 创建测试主题
docker exec -it kafka kafka-topics.sh --create --topic test-topic --bootstrap-server kafka:9092 --partitions 1 --replication-factor 1

# 查看主题列表
docker exec -it kafka kafka-topics.sh --list --bootstrap-server kafka:9092

# 发送测试消息
docker exec -it kafka kafka-console-producer.sh --broker-list kafka:9092 --topic test-topic
> Hello Kafka!
> Welcome to Docker!

# 消费测试消息（新开终端）
docker exec -it kafka kafka-console-consumer.sh --bootstrap-server kafka:9092 --topic test-topic --from-beginning

# 查看主题详情
docker exec -it kafka kafka-topics.sh --describe --topic test-topic --bootstrap-server kafka:9092

部署 Nginx
3.2.7.1 创建数据目录
mkdir -p /data/docker/nginx/{conf,html,logs}

3.2.7.2 创建 Nginx 配置文件
cat > /data/docker/nginx/conf/nginx.conf <<EOF
user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '\$remote_addr - \$remote_user [\$time_local] "\$request" '
                      '\$status \$body_bytes_sent "\$http_referer" '
                      '"\$http_user_agent" "\$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;

    keepalive_timeout  65;

    gzip  on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    include /etc/nginx/conf.d/*.conf;
}
EOF

3.2.7.3 创建 Nginx 配置文件
cat > /data/docker/nginx/conf.d/default.conf <<EOF
server {
    listen 80;
    server_name localhost;

    location /nacos/ {
        proxy_pass http://nacos:8848/nacos/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }

    location /rabbitmq/ {
        proxy_pass http://rabbitmq:15672/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }

    location /rocketmq/ {
        proxy_pass http://rmqconsole:8080/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }

    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }

    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;

    location = /50x.html {
        root /usr/share/nginx/html;
    }
}
EOF

3.2.7.4 使用 Docker 启动 Nginx
docker run -d \
    --name nginx \
    --restart=always \
    --link nacos:nacos \
    --link rabbitmq:rabbitmq \
    --link rmqconsole:rmqconsole \
    -p 60010:80 \
    -v /data/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
    -v /data/docker/nginx/conf.d:/etc/nginx/conf.d \
    -v /data/docker/nginx/html:/usr/share/nginx/html \
    -v /data/docker/nginx/logs:/var/log/nginx \
    nginx:1.25

验证 Nginx 安装
curl http://服务器IP/

访问 Nginx 路由：
Nacos: http://服务器IP:60010/nacos/
RabbitMQ: http://服务器IP:60010/rabbitmq/
RocketMQ: http://服务器IP:60010/rocketmq/

使用 Docker Compose 一键部署
3.3.1 创建 docker-compose.yml
mkdir -p /data/docker && cd /data/docker
cat > docker-compose.yml <<EOF
version: '3.8'

services:
  mysql:
    image: mysql:5.7
    container_name: mysql
    restart: always
    ports:
      - "60001:3306"
    volumes:
      - ./mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf
      - ./mysql/data:/var/lib/mysql
      - ./mysql/logs:/logs
    environment:
      MYSQL_ROOT_PASSWORD: "password123"
      MYSQL_DATABASE: "nacos_config"
      TZ: "Asia/Shanghai"
    networks:
      - app-network

  redis:
    image: redis:6.2
    container_name: redis
    restart: always
    ports:
      - "60002:6379"
    volumes:
      - ./redis/conf/redis.conf:/etc/redis/redis.conf
      - ./redis/data:/data
    command: redis-server /etc/redis/redis.conf
    environment:
      TZ: "Asia/Shanghai"
    networks:
      - app-network

  nacos:
    image: nacos/nacos-server:v3.0.2
    container_name: nacos
    restart: always
    ports:
      - "60003:8848"
      - "9848:9848"
      - "9849:9849"
    volumes:
      - ./nacos/conf/application.properties:/home/nacos/conf/application.properties
      - ./nacos/data:/home/nacos/data
      - ./nacos/logs:/home/nacos/logs
    environment:
      MODE: "standalone"
      NACOS_SERVER_PORT: "8848"
      PREFER_HOST_MODE: "hostname"
      TZ: "Asia/Shanghai"
    depends_on:
      - mysql
    networks:
      - app-network

  rabbitmq:
    image: rabbitmq:3.12-management
    container_name: rabbitmq
    restart: always
    ports:
      - "60004:5672"
      - "60005:15672"
    volumes:
      - ./rabbitmq/data:/var/lib/rabbitmq
      - ./rabbitmq/logs:/var/log/rabbitmq
    environment:
      RABBITMQ_DEFAULT_USER: "admin"
      RABBITMQ_DEFAULT_PASS: "password123"
      TZ: "Asia/Shanghai"
    networks:
      - app-network

  rmqnamesrv:
    image: apache/rocketmq:4.9.5
    container_name: rmqnamesrv
    restart: always
    ports:
      - "60006:9876"
    volumes:
      - ./rocketmq/namesrv/data:/root/store
    environment:
      MAX_POSSIBLE_HEAP: "1024m"
      TZ: "Asia/Shanghai"
    command: sh mqnamesrv
    networks:
      - app-network

  rmqbroker:
    image: apache/rocketmq:4.9.5
    container_name: rmqbroker
    restart: always
    ports:
      - "10911:10911"
      - "10909:10909"
    volumes:
      - ./rocketmq/broker/data:/root/store
      - ./rocketmq/broker/logs:/root/logs
    environment:
      NAMESRV_ADDR: "rmqnamesrv:9876"
      MAX_POSSIBLE_HEAP: "2048m"
      TZ: "Asia/Shanghai"
    depends_on:
      - rmqnamesrv
    command: sh mqbroker -c /etc/rocketmq/broker.conf
    networks:
      - app-network

  rmqconsole:
    image: styletang/rocketmq-console-ng:2.0.0
    container_name: rmqconsole
    restart: always
    ports:
      - "60007:8080"
    environment:
      NAMESRV_ADDR: "rmqnamesrv:9876"
      TZ: "Asia/Shanghai"
    depends_on:
      - rmqnamesrv
    networks:
      - app-network

  zookeeper:
    image: zookeeper:3.8
    container_name: zookeeper
    restart: always
    ports:
      - "60008:2181"
    volumes:
      - ./kafka/zookeeper/data:/data
      - ./kafka/zookeeper/logs:/datalog
    environment:
      ZOO_MY_ID: "1"
      ZOO_SERVERS: "server.1=0.0.0.0:2888:3888;2181"
      TZ: "Asia/Shanghai"
    networks:
      - app-network

  kafka:
    image: wurstmeister/kafka:2.13-2.8.1
    container_name: kafka
    restart: always
    ports:
      - "9092:9092"
      - "60009:9093"
    volumes:
      - ./kafka/kafka/data:/kafka/data
    environment:
      KAFKA_BROKER_ID: "1"
      KAFKA_ZOOKEEPER_CONNECT: "zookeeper:2181"
      KAFKA_ADVERTISED_LISTENERS: "PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:9093"
      KAFKA_LISTENERS: "PLAINTEXT://0.0.0.0:9092,PLAINTEXT_HOST://0.0.0.0:9093"
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT"
      KAFKA_INTER_BROKER_LISTENER_NAME: "PLAINTEXT"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: "1"
      TZ: "Asia/Shanghai"
    depends_on:
      - zookeeper
    networks:
      - app-network

  nginx:
    image: nginx:1.25
    container_name: nginx
    restart: always
    ports:
      - "60010:80"
    volumes:
      - ./nginx/conf/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/html:/usr/share/nginx/html
      - ./nginx/logs:/var/log/nginx
    depends_on:
      - nacos
      - rabbitmq
      - rmqconsole
    networks:
      - app-network

networks:
  app-network:
    driver: bridge
EOF

3.3.2 创建配置文件目录结构
mkdir -p /data/docker/{mysql/conf,mysql/data,mysql/logs,redis/conf,redis/data,nacos/conf,nacos/data,nacos/logs,rabbitmq/data,rabbitmq/logs,rocketmq/namesrv/data,rocketmq/broker/data,rocketmq/broker/logs,kafka/zookeeper/data,kafka/zookeeper/logs,kafka/kafka/data,nginx/conf,nginx/conf.d,nginx/html,nginx/logs}

3.3.3 创建 MySQL 配置文件
cat > /data/docker/mysql/conf/my.cnf <<EOF
[mysqld]
user=mysql
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
default-time-zone=+8:00
max_connections=1000
wait_timeout=28800
interactive_timeout=28800
query_cache_type=0
query_cache_size=0
lower_case_table_names=1
EOF

3.3.4 创建 Redis 配置文件
cat > /data/docker/redis/conf/redis.conf <<EOF
bind 0.0.0.0
protected-mode no
port 6379
daemonize no
requirepass password123
appendonly yes
EOF

3.3.5 创建 Nacos 配置文件
cat > /data/docker/nacos/conf/application.properties <<EOF
server.servlet.contextPath=/nacos
server.port=8848

spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://mysql:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
db.user=root
db.password=password123

nacos.core.auth.system.type=nacos
nacos.core.auth.enabled=true
nacos.core.auth.server.identity.key=nacos
nacos.core.auth.server.identity.value=nacos
nacos.core.auth.plugin.nacos.token.secret.key=SecretKey01234567890123456789012345678901234567890123456789012345
EOF

3.3.6 启动服务
cd /data/docker
docker compose up -d

3.3.7 查看服务状态
docker compose ps

3.3.8 创建 Nginx 配置文件
cat > /data/docker/nginx/conf/nginx.conf <<EOF
user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '\$remote_addr - \$remote_user [\$time_local] "\$request" '
                      '\$status \$body_bytes_sent "\$http_referer" '
                      '"\$http_user_agent" "\$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;

    keepalive_timeout  65;

    gzip  on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    include /etc/nginx/conf.d/*.conf;
}
EOF

3.3.9 创建 Nginx 配置文件
cat > /data/docker/nginx/conf.d/default.conf <<EOF
server {
    listen 80;
    server_name localhost;

    location /nacos/ {
        proxy_pass http://nacos:8848/nacos/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }

    location /rabbitmq/ {
        proxy_pass http://rabbitmq:15672/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }

    location /rocketmq/ {
        proxy_pass http://rmqconsole:8080/;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }

    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }

    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;

    location = /50x.html {
        root /usr/share/nginx/html;
    }
}
EOF

启动服务cd /data/docker
docker compose up -d

3.3.11 查看服务状态
docker compose ps

3.2.12 停止服务
docker compose down

Docker 常用命令
# 查看运行中的容器
docker ps

# 查看所有容器
docker ps -a

# 查看容器日志
docker logs -f 容器名

# 进入容器
docker exec -it 容器名 bash

# 重启容器
docker restart 容器名

# 停止容器
docker stop 容器名

# 删除容器
docker rm 容器名

# 查看镜像
docker images

# 删除镜像
docker rmi 镜像名

Docker Compose 常用命令
# 启动服务
docker compose up -d

# 停止服务
docker compose down

# 查看服务状态
docker compose ps

# 查看日志
docker compose logs -f

# 重启服务
docker compose restart

# 查看配置
docker compose config

Docker 版本选择建议
1.生产环境：选择 24.0.x LTS 版本，稳定性和安全性有保障
2.开发环境：可以使用最新版本 25.0.x，体验新特性
3.旧系统兼容：CentOS 7 / Ubuntu 18.04 建议使用 20.10.x
4.Compose 版本：统一使用 Docker Compose v2，v1 已弃用

5.8 版本检查命令# 检查操作系统版本
cat /etc/os-release

# 检查内核版本
uname -r

# 检查当前 Docker 版本（如已安装）
docker --version

# 检查 Docker Compose 版本（如已安装）
docker compose version

常见问题与排查命令
6.1 Docker 启动失败
# 查看 Docker 服务状态
systemctl status docker

# 查看 Docker 详细日志
journalctl -u docker -f

# 检查 Docker 配置文件
cat /etc/docker/daemon.json

# 验证 Docker 配置是否正确
docker daemon-reload

# 重启 Docker 服务
systemctl restart docker

# 检查 Docker 进程
ps aux | grep docker

# 检查 Docker 存储目录
df -h /var/lib/docker

6.2 Docker 镜像拉取失败
# 测试镜像源连通性
curl -I https://registry-1.docker.io/v2/

# 检查镜像加速器配置
cat /etc/docker/daemon.json | grep registry-mirrors

# 手动拉取镜像测试
docker pull mysql:5.7

# 清理 Docker 缓存
docker system prune -a

# 检查 DNS 配置
cat /etc/resolv.conf

# 测试网络连通性
ping docker.io

Docker 容器启动失败
# 查看容器详细信息
docker inspect 容器名

# 查看容器日志（最近100行）
docker logs --tail=100 容器名

# 查看容器启动失败原因
docker run --rm 镜像名 命令

# 检查容器端口映射
docker port 容器名

# 检查容器网络
docker network ls
docker network inspect bridge

# 强制重启容器
docker restart 容器名

# 删除并重建容器
docker rm -f 容器名

MySQL 无法连接# 检查 MySQL 容器状态
docker ps | grep mysql

# 查看 MySQL 容器日志
docker logs mysql

# 进入 MySQL 容器内部检查
docker exec -it mysql bash
mysql -uroot -ppassword123

# 检查端口占用
netstat -tlnp | grep 3306
ss -tlnp | grep 3306

# 检查防火墙规则
firewall-cmd --list-ports
firewall-cmd --add-port=3306/tcp --permanent
firewall-cmd --reload

# 检查 SELinux 状态
getenforce
ls -laZ /data/docker/mysql/data

# 测试远程连接
mysql -h 服务器IP -P 3306 -u root -ppassword123

# 检查 MySQL 配置文件
cat /data/docker/mysql/conf/my.cnf

# 查看 MySQL 进程列表
docker exec -it mysql mysql -uroot -ppassword123 -e "SHOW PROCESSLIST;"

# 查看 MySQL 错误日志
docker exec -it mysql cat /var/log/mysql/error.log

MySQL 数据目录权限问题
# 检查数据目录权限
ls -la /data/docker/mysql/data

# 修改数据目录权限
chown -R 999:999 /data/docker/mysql/data

# 修改数据目录 SELinux 标签
chcon -R -t mysqld_db_t /data/docker/mysql/data

Redis 无法连接
# 检查 Redis 容器状态
docker ps | grep redis

# 查看 Redis 日志
docker logs redis

# 进入 Redis 容器检查
docker exec -it redis redis-cli -a password123

# 测试 Redis 连接
redis-cli -h 服务器IP -p 6379 -a password123 ping

# 检查 Redis 配置文件
cat /data/docker/redis/conf/redis.conf

# 检查端口占用
netstat -tlnp | grep 6379

# 检查防火墙
firewall-cmd --list-ports | grep 6379

# 查看 Redis 内存使用
docker exec -it redis redis-cli -a password123 info memory

# 查看 Redis 客户端连接
docker exec -it redis redis-cli -a password123 info clients

6.7 Redis 密码认证失败# 检查密码配置
grep requirepass /data/docker/redis/conf/redis.conf

# 无密码连接方式（需先关闭保护模式）
redis-cli -h 服务器IP -p 6379

# 在容器内重置密码
docker exec -it redis redis-cli
127.0.0.1:6379> CONFIG SET requirepass "newpassword"

Nacos 启动失败
# 检查 Nacos 容器状态
docker ps | grep nacos

# 查看 Nacos 完整日志
docker logs nacos

# 查看 Nacos 最近日志
docker logs --tail=200 nacos

# 检查 MySQL 数据库连接
docker exec -it mysql mysql -uroot -ppassword123 -e "SHOW DATABASES;"
docker exec -it mysql mysql -uroot -ppassword123 nacos_config -e "SHOW TABLES;"

# 检查 Nacos 配置文件
cat /data/docker/nacos/conf/application.properties

# 测试 Nacos 端口连通性
telnet 服务器IP 8848
curl http://服务器IP:8848/nacos/v1/ns/health/liveness

# 检查 Nacos JVM 内存配置
docker exec -it nacos cat /home/nacos/bin/startup.sh | grep JVM

# 检查磁盘空间
df -h /data/docker/nacos

# 检查 Nacos 数据目录
ls -la /data/docker/nacos/data

Nacos 控制台无法访问
# 检查端口映射
docker port nacos

# 检查防火墙
firewall-cmd --list-ports | grep 8848

# 检查网络连通性
curl -I http://localhost:8848/nacos
curl -I http://服务器IP:8848/nacos

# 检查 Nacos 服务状态
curl http://localhost:8848/nacos/v1/ns/health/liveness
curl http://localhost:8848/nacos/v1/ns/health/readiness

# 检查 Nacos 配置中心 API
curl "http://localhost:8848/nacos/v1/cs/configs?dataId=example&group=DEFAULT_GROUP"

Nacos 服务注册失败
# 检查 Nacos 命名空间
curl "http://localhost:8848/nacos/v1/ns/namespace/list"

# 检查服务列表
curl "http://localhost:8848/nacos/v1/ns/service/list?pageNo=1&pageSize=10&namespaceId="

# 检查 Nacos 认证配置
cat /data/docker/nacos/conf/application.properties | grep auth

# 测试服务注册
curl -X POST "http://localhost:8848/nacos/v1/ns/instance" \
  -d "serviceName=test-service&ip=127.0.0.1&port=8080&weight=1.0&namespaceId="

# 查看 Nacos 服务详情
curl "http://localhost:8848/nacos/v1/ns/instance/list?serviceName=test-service&namespaceId="


Docker Compose 命令问题
# 检查 Compose 版本
docker compose version
docker-compose version

# 验证 Compose 文件语法
docker compose config

# 查看 Compose 服务状态
docker compose ps

# 查看 Compose 服务日志
docker compose logs -f
docker compose logs -f mysql
docker compose logs -f nacos

# 重启单个服务
docker compose restart mysql

# 停止单个服务
docker compose stop redis

# 查看 Compose 网络
docker compose network ls

# 查看 Compose 卷
docker compose volume ls

# 删除所有服务（保留数据卷）
docker compose down

# 删除所有服务和数据卷
docker compose down -v

Docker 网络问题
# 查看所有网络
docker network ls

# 查看网络详细信息
docker network inspect app-network

# 检查容器网络配置
docker inspect mysql | grep -A 20 "Networks"

# 测试容器间网络连通性
docker exec -it nacos ping mysql
docker exec -it nacos telnet mysql 3306

# 查看容器 IP 地址
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' mysql

# 创建自定义网络
docker network create --driver bridge app-network

# 连接容器到网络
docker network connect app-network mysql

# 断开容器网络
docker network disconnect app-network mysql

Docker 资源占用过高
# 查看 Docker 资源使用
docker stats

# 查看容器资源使用详情
docker stats mysql redis nacos

# 查看系统内存使用
free -h

# 查看系统 CPU 使用
top

# 查看磁盘使用
df -h

# 查看 Docker 镜像占用
docker system df

# 清理未使用的资源
docker system prune -a

# 清理指定容器日志
truncate -s 0 /var/lib/docker/containers/*/*-json.log

时间同步问题
# 查看系统时间
date

# 查看容器时间
docker exec -it mysql date
docker exec -it nacos date

# 检查时区设置
cat /etc/timezone
timedatectl

# 同步系统时间
ntpdate ntp.aliyun.com

# 安装时间同步服务
yum install -y ntp
systemctl start ntpd
systemctl enable ntpd

文件权限问题
# 检查挂载目录权限
ls -la /data/docker/

# 修改目录权限
chown -R root:root /data/docker/
chmod -R 755 /data/docker/

# 检查 SELinux 上下文
ls -laZ /data/docker/

# 设置 SELinux 上下文
chcon -Rt svirt_sandbox_file_t /data/docker/

# 临时关闭 SELinux
setenforce 0

# 永久关闭 SELinux
sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

注意事项
1.数据备份：定期备份 /data/docker 目录下的数据
2.密码安全：生产环境请修改默认密码
3.防火墙：生产环境建议开放必要端口而非关闭防火墙
4.资源配置：根据实际业务需求调整容器内存和 CPU 限制
5.镜像版本：建议使用固定版本标签而非 latest
6.网络模式：生产环境建议使用自定义网络而非默认 bridge