Linux下Docker安装几种NoSQL和MQ和DB

urlyy
  2022-02-28 13:27:48 2022-02-28 13:27:48 创建   2023-06-19 13:29:20 2023-06-19 13:29:20 更新   

注：本文中所有配置文件都是我用echo或者cat输入的，不全，最好用docker cp
如下面的diamagnetic就是将mysql-service容器内的配置文件复制到宿主机上
然后在第二次运行的时候再挂载

1
docker cp mysql-service:/etc/mysql/my.cnf /root/docker/mysql/conf

我的服务器是本地虚拟机，所以直接关了防火墙
具体要开的端口是
mongodb:27017
redis:6379
es + kibana:9200 9300 5601
rabbitmq 5672 15672

Docker

  1. 卸载（可选）如果之前安装过旧版本的Docker，可以使用下面命令卸载：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-selinux \
    docker-engine-selinux \
    docker-engine \
    docker-ce
  2. 安装docker。服务器机器要能联网，安装yum工具
    1
    2
    3
    yum install -y yum-utils \
    device-mapper-persistent-data \
    lvm2 --skip-broken
  3. 更新本地镜像源，这里设为了阿里云的镜像
    1
    2
    3
    yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    1
    sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo
    1
    yum makecache fast
  4. 安装docker社区版
    1
    yum install -y docker-ce
  5. 启动docker
    1
    2
    systemctl start docker 
    systemctl enable docker
  6. 查看docker版本，验证启动成功
    1
    docker -v
  7. 配置镜像加速。这里参考阿里云的镜像加速文档：加速文档 ，把文档里的代码直接全粘了运行docker官方镜像仓库网速较差，我们需要设置国内镜像服务。
    1
    2
    3
    4
    5
    6
    7
    8
    sudo mkdir -p /etc/docker
    sudo tee /etc/docker/daemon.json <<-'EOF'
    {
      "registry-mirrors": ["https://ppztf0yr.mirror.aliyuncs.com"]
    }
    EOF
    sudo systemctl daemon-reload
    sudo systemctl restart docker

docker常用命令

docker常用命令

MongoDB

  1. 我是拉取最新版的

    1
    docker pull mongo

  2. 预先创建好被挂载的配置文件
    mongodb.conf 配置文件详解 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    mkdir -p /myData/mongo/conf
    mkdir -p /myData/mongo/data
    mkdir -p /myData/mongo/log
    cd /myData/mongo/conf
    cat > mongodb.conf <<EOF
    #端口
    port=27017
    #数据库文件存放目录
    dbpath=/myData/mongo/data
    #日志文件存放路径
    logpath=/myData/mongo/log
    #使用追加方式写日志
    logappend=true
    #以守护线程的方式运行，创建服务器进程
    fork=true
    #最大同时连接数
    maxConns=100
    #不启用验证
    #noauth=true
    #每次写入会记录一条操作日志
    journal=true
    #存储引擎有mmapv1、wiredTiger、mongorocks
    storageEngine=wiredTiger
    #访问IP
    bind_ip=0.0.0.0
    #用户验证
    auth=true
    EOF

  3. 新建一个名为mongo的容器运行该mongo镜像，映射宿主机的 27017 端口为容器服务的 27017 端口，并指定要验证才能使用服务
    在这里插入图片描述

    1
    2
    3
    4
    5
    docker run \
    --name mongo \
    -p 27017:27017 \
    -v /myData/mongo/data:/data/db -v /myData/mongo/conf:/data/conf -v /myData/mongo/log:/data/log \
    -d mongo --auth

  4. 查看运行情况

    1
    docker ps

  5. 进入容器

    1
    docker exec -it mongo mongo admin

    接下来的角色权限配置可以参考MongoDB的角色创建及配置

  6. 创建用户

    1
    db.createUser({user:"root",pwd:"root",roles:["root"]});

  7. 尝试登录该用户，输出1表示成功(同redis的auth)

    1
    db.auth('root','root')

    用可视化工具连接时也是username和password都是root

  8. 退出

    1
    exit

Redis

参考自docker拉取Redis

  1. 拉取

    1
    docker pull redis

  2. 预先创建好挂载目录及文件
    注意daemonize不能为yes，因为docker run里的-d就是守护进程
    参考自docker日记（二）–redis 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    mkdir -p /myData/redis/conf
    mkdir -p /myData/redis/data
    touch /myData/redis/conf/redis.conf
    cat > /myData/redis/conf/redis.conf <<EOF
    bind 0.0.0.0 
    protected-mode no
    appendonly yes 
    requirepass root
    daemonize no
    EOF
    chmod -R 777 /myData/redis/

  3. 创建容器运行该镜像
    -v /myData/redis/data:/data \【-v：目录挂载，将容器内部的data 文件夹挂载到Linux的/myData/redis/data目录里】
    -V /myData/redis/conf/redis.conf:/etc/redis/redis.conf \【将/etc/redis/redis.conf挂载到Linux中指定目录下】
    -d --restart=always 【配置开机启动】
    TIMEZONE解决redis时区不同步问题
    注意最后一行是用容器内配置文件启动redis服务端

    1
    2
    3
    4
    5
    6
    docker run -p 6379:6379 --name redis \
    --sysctl net.core.somaxconn=1024 --privileged=true --restart=always \
    -v /myData/redis/data:/data \
    -v /myData/redis/conf/redis.conf:/etc/redis/redis.conf \
    -e TIME_ZONE="Asia/Shanghai" -e TZ="Asia/Shanghai" \
    -d redis redis-server /etc/redis/redis.conf

  4. 进入客户端

    1
    docker exec -it redis redis-cli

  5. 测试
    注意下面这个root是我们之前配的密码，如果你想免密，就把那行删掉或注释掉

    1
    2
    3
    auth root
    ping
    exit

    返回PONG即成功

Elasticsearch

  1. 拉取
    1
    2
    docker pull elasticsearch:7.6.2
    docker pull kibana:7.6.2
  2. 准备好外部挂在目录和文件，这里文件就用我给出的吧，别复制容器里的了，甚至都不如这里的全
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    mkdir -p /myData/elasticsearch/config 
    mkdir -p /myData/elasticsearch/plugins
    mkdir -p /myData/kibana/config
    mkdir -p /myData/kibana/data
    cat > /myData/elasticsearch/config/elasticsearch.yml <<EOF
    http.host: 0.0.0.0
    # Uncomment the following lines for a production cluster deployment
    #transport.host: 0.0.0.0
    #discovery.zen.minimum_master_nodes: 1
    #Password config
    #这一步是开启x-pack插件
    xpack.security.enabled: true   
    http.cors.enabled: true
    http.cors.allow-origin: "*"
    EOF
    cat > /myData/kibana/config/kibana.yml<<EOF
    server.name: kibana
    server.host: "0.0.0.0"
    elasticsearch.hosts: [ "http://es服务器的IP:9200" ]
    elasticsearch.username: "elastic"
    elasticsearch.password: "自己待会会设置的密码"
    i18n.locale: "zh-CN"
    EOF
  3. 新建容器运行该镜像
    1
    2
    3
    4
    5
    6
    7
    8
    docker run -d -it --restart=always --privileged=true \
    --name=elasticsearch -p 9200:9200 -p 9300:9300 -p 5601:5601 \
     -e "discovery.type=single-node" -e "cluster.name=elasticsearch" \
     -v /myData/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
     -v /myData/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
     -e ES_JAVA_OPTS="-Xms512M -Xmx512M" elasticsearch:7.6.2
     
    #-e ES_JAVA_OPTS="-Xms4G -Xmx4G"  设置运行内存，这个内存不建议太大。因为es走的是直接内存也就是系统内存，所以要预留足够的系统内存。我这台服务器8核16G所以给了4G。如果系统内存预留不足，会导致以后检索时速度达不到预期速度。
  4. 进入es容器设置密码
    1
    2
    3
    4
    docker exec -it elasticsearch /bin/bash
    cd bin
    #开启密码设置
    elasticsearch-setup-passwords interactive
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    #输出 如下
    Initiating the setup of passwords for reserved users elastic,apm_system,kibana,kibana_system,logstash_system,beats_system,remote_monitoring_user.
    You will be prompted to enter passwords as the process progresses.
    #输入Y
    Please confirm that you would like to continue [y/N]Y
    #依次设置密码
    Enter password for [elastic]:
    Reenter password for [elastic]:
    Enter password for [apm_system]:
    Reenter password for [apm_system]:
    Enter password for [kibana_system]:
    Reenter password for [kibana_system]:
    Enter password for [logstash_system]:
    Reenter password for [logstash_system]:
    Enter password for [beats_system]:
    Reenter password for [beats_system]:
    Enter password for [remote_monitoring_user]:
    Reenter password for [remote_monitoring_user]:
    Changed password for user [apm_system]
    Changed password for user [kibana_system]
    Changed password for user [kibana]
    Changed password for user [logstash_system]
    Changed password for user [beats_system]
    Changed password for user [remote_monitoring_user]
    Changed password for user [elastic]
  5. 重启es
    1
    exit
    1
    docker restart elasticsearch
  6. 修改kibana.yml的配置
  7. 新建kibana容器(kibana是一个可视化es数据的管理平台)
    1
    2
    docker run -itd -e ELASTICSEARCH_URL=http://ES服务器IP:9200 --name kibana \
    -v /myData/kibana/config:/usr/share/kibana/config --network=container:elasticsearch kibana:7.6.2
  8. 测试
    http://ES服务器IP:9200
    如下面的效果并能正确登录说明成功了
    注意用户名是elastic
    在这里插入图片描述
    http://kibana服务器IP:5601/
    在这里插入图片描述

RabbitMQ

  1. 拉镜像

    1
    docker pull rabbitmq:management

  2. 准备好外部挂载目录

    1
    2
    mkdir -p /myData/rabbitmq/{data,log,conf}
    chmod -R 777 /myData/rabbitmq

  3. 新建容器运行该镜像

    1
    2
    3
    4
    docker run -d -p 5672:5672 -p 15672:15672 \
    -v /myData/rabbitmq/data:/var/lib/rabbitmq -v /myData/rabbitmq/conf:/etc/rabbitmq -v /myData/rabbitmq/log:/var/log/rabbitmq \
    --name rabbitmq --hostname=rabbitmq-1 --restart=always \
    rabbitmq:management

  4. 进入容器

    1
    docker exec -it rabbitmq  /bin/bash

  5. 启动可视化插件

    1
    rabbitmq-plugins enable rabbitmq_management

  6. 建立供外部访问的用户
    先别急着退出来，还在这个容器里
    添加账号 rabbitmqctl add_user 账号 密码
    设置权限 rabbitmqctl set_permissions -p / 账号 ".*" ".*" ".*"
    设置角色rabbitmqctl set_user_tags 账号 administrator

    1
    2
    3
    rabbitmqctl add_user root root
    rabbitmqctl set_permissions -p / root ".*" ".*" ".*"
    rabbitmqctl set_user_tags root administrator

  7. 测试
    访问web界面
    http://rabbitmq服务器的IP:15672/
    有个默认账号和密码都是guest
    当然也可以用我们刚创建的那一个
    在这里插入图片描述

RocketMQ

参考自Rocketmq详解02-mq安装

  1. 创建namesrv服务
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    docker pull rocketmqinc/rocketmq

    mkdir -p /myData/rocketmq/data/namesrv/logs /myData/rocketmq/data/namesrv/store

    docker run -d \
    --restart=always \
    --name rmqnamesrv \
    -p 9876:9876 \
    -v /myData/rocketmq/data/namesrv/logs:/root/logs \
    -v /myData/rocketmq/data/namesrv/store:/root/store \
    -e "MAX_POSSIBLE_HEAP=100000000" \
    rocketmqinc/rocketmq \
    sh mqnamesrv
  2. 创建broke结点
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    mkdir -p  /myData/rocketmq/data/broker/logs   /myData/rocketmq/data/broker/store /myData/rocketmq/conf

    cat > /myData/rocketmq/conf/broker.conf <<EOF
    # 所属集群名称，如果节点较多可以配置多个
    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 = IP自己填
    EOF

    docker run -d  \
    --restart=always \
    --name rmqbroker \
    --link rmqnamesrv:namesrv \
    -p 10911:10911 \
    -p 10909:10909 \
    -v  /myData/rocketmq/data/broker/logs:/root/logs \
    -v  /myData/rocketmq/data/broker/store:/root/store \
    -v /myData/rocketmq/conf/broker.conf:/opt/rocketmq/conf/broker.conf \
    -e "NAMESRV_ADDR=namesrv:9876" \
    -e "MAX_POSSIBLE_HEAP=200000000" \
    rocketmqinc/rocketmq \
    sh mqbroker -c /opt/rocketmq/conf/broker.conf
  3. 创建rocketmq-console
    1
    2
    3
    4
    5
    6
    7
    8
    9
    docker pull pangliang/rocketmq-console-ng

    docker run -d \
    --restart=always \
    --name rmqadmin \
    -e "JAVA_OPTS=-Drocketmq.namesrv.addr=IP:9876 \
    -Dcom.rocketmq.sendMessageWithVIPChannel=false" \
    -p 9111:8080 \
    pangliang/rocketmq-console-ng
  4. 开放对应端口
    1
    2
    3
    4
    5
    firewall-cmd --permanent --zone=public --add-port=9876/tcp
    firewall-cmd --permanent --zone=public --add-port=10911/tcp
    firewall-cmd --permanent --zone=public --add-port=9111/tcp
    # 立即生效
    firewall-cmd --reload
  5. 记得开放9876，10911，10912，10909、9111(自定义的控制台端口)五个端口
  6. 查看控制台
    http://ip:9111

Docker-Compose

  1. 下载 并到服务器上
    在这里插入图片描述
  2. mv docker-compose-linux-x86_64 docker-compose
  3. chmod 777 docker-compose
  4. mv docker-compose /usr/local/bin/
  5. vim /etc/profile、export PATH=$PATH:/usr/local/bin/、source /etc/profile
  6. docker-compose -v
    Docker-compose安装 
1
2
3
4
5
6
docker-compose up
docker-compose restart
docker-compose logs
docker-compose ps
docker-compose stop
docker-compose rm

Mysql

1
2
3
4
5
6
7
8
9
10
# 拉取
docker pull mysql
# 运行
docker run -p 3306:3306 --name mysql \
-e MYSQL\_ROOT\_PASSWORD=root \
-d mysql
# 进入容器测试
docker exec -it mysql bash
mysql -uroot -p
密码

在3307端口装一个5.7的mysql

1
2
3
docker run -p 3307:3306 --name mysql5.7 \
-e MYSQL\_ROOT\_PASSWORD=root\
-d mysql:5.7

MinIO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
docker pull minio/minio
mkdir /myData
mkdir /myData/minio
mkdir /myData/minio/data
mkdir /myData/minio/config

docker run --name minio \
-p 9000:9000 \
-p 9999:9999 \
-d --restart=always \
-e "MINIO_ROOT_USER=admin" \
-e "MINIO_ROOT_PASSWORD=admin123" \
-e "MINIO_SERVER_URL=http://IP:9000" \
-v /home/minio/data:/data \
-v /home/minio/config:/root/.minio \
minio/minio server /data \
--console-address '0.0.0.0:9999'


firewall-cmd --zone=public --add-port=9000/tcp --permanent
firewall-cmd --zone=public --add-port=9999/tcp --permanent
firewall-cmd --reload

登录console
http://IP:9999
用户名和密码为
admin admin123

Milvus

1
2
3
4
5
mkdir /usr/local/env/milvus
cd /usr/local/env/milvus
wget https://github.com/milvus-io/milvus/releases/download/v2.0.0-rc7/milvus-standalone-docker-compose.yml -O docker-compose.yml
docker-compose up -d
docker-compose ps

Nginx

Docker 安装 Nginx 容器 (完整详细版) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
docker pull nginx
# 创建挂载目录
mkdir -p /mydata/nginx/conf
mkdir -p /mydata/nginx/log
mkdir -p /mydata/nginx/html
# 生成临时容器(复制完配置文件就删除)
docker run --name nginx -p 80:80 -d nginx
# 将容器中要被挂载的文件复制到宿主机
docker cp nginx:/etc/nginx/nginx.conf /mydata/nginx/conf/nginx.conf
docker cp nginx:/etc/nginx/conf.d /mydata/nginx/conf/conf.d
docker cp nginx:/usr/share/nginx/html /mydata/nginx/
# 删除临时的
docker stop nginx
docker rm nginx
# 真正启动容器
docker run \
-p 80:80 \
--name nginx \
-v /mydata/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /mydata/nginx/conf/conf.d:/etc/nginx/conf.d \
-v /mydata/nginx/log:/var/log/nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \
-d nginx

PostgreSQL

1
2
3
4
5
6
7
8
9
10
11
12
13
docker pull postgres
mkdir /myData/postgresql


docker run --name postgres \
    --restart=always \
    -e POSTGRES_PASSWORD=root \
    -p 5432:5432 \
    -v /myData/postgresql:/var/lib/postgresql/data \
    -d postgres

# 查看
docker ps
  • 标题: Linux下Docker安装几种NoSQL和MQ和DB
  • 作者: urlyy
  • 创建于 : 2022-02-28 13:27:48
  • 更新于 : 2023-06-19 13:29:20
  • 链接: https://urlyy.github.io/2022/02/28/Linux下Docker安装几种NoSQL和MQ/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
此页目录
Linux下Docker安装几种NoSQL和MQ和DB
  1. Docker
    1. docker常用命令
  2. MongoDB
  3. Redis
  4. Elasticsearch
  5. RabbitMQ
  6. RocketMQ
  7. Docker-Compose
  8. Mysql
  9. MinIO
  10. Milvus
  11. Nginx
  12. PostgreSQL