使用Docker启动各种服务，学校的学妹拍手叫好

开机启动设置

设置容器开机自动启动

 docker update 容器id/容器名 --restart=always

设置开机不自动启动

 docker update 容器id/容器名 --restart=no

设置开机启动docker

systemctl enable docker

docker安装mysql

下载镜像文件

# 拉取镜像
sudo docker pull mysql:5.7

# 查看全部镜像
sudo docker images

创建实例并启动

# 切换成root用户，密码为vagrant
su root

# 创建并运行容器
docker run -d -p 3306:3306 --name mysql \
-v /mydata/mysql/conf:/etc/mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=此处为密码 mysql:5.7

# 参数说明
#  -d 后台运行
#  -p 端口映射
#  -v 卷挂载
#  -e 环境配置
#  --name 容器名字

# 查看运行的容器
docker ps

修改配置文件

vim 修改 /mydata/mysql/conf/my.conf 下的 mysql 配置文件

# 如果没有 vim 命令则安装 vim
yum install vim

# 进入配置文件
vim /mydata/mysql/conf/my.conf

# 文件内容
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve

# 重启容器
docker restart mysql

进入容器

每个容器，相当于在 linux 内开辟一个小型的 linux

通过 docker exec -it 容器id/容器名 bin/bash 进入容器

可看到与linux系统相同的目录结构

在容器中可以使用 ctrl + p + q 返回 linux ，这时容器并不会停止运行

然后使用可视化工具连接即可，比如 navicat 或者 sqlyog 或者 datagrip

docker安装redis

拉取镜像文件

docker pull redis

创建实例并且启动

默认挂载它会把 redis.conf 挂载成目录，所以我们要事先创建 redis.conf 文件，然后再挂载

mkdir -p /mydata/redis/conf
touch /mydata/redis/conf/redis.conf

# touch命令有两个功能
# ①是用于把已存在文件的时间标签更新为系统当前的时间（默认方式），它们的数据将原封不动地保留下来;
# ②是用来创建新的空文件。

docker run -p 6379:6379 --name redis \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--requirepass "此处设置密码"

持久化

默认是不持久化的，在配置文件中输入appendonly yes，就可以 AOF (append only file) 持久化了，存到了文件中了。

vim /mydata/redis/conf/redis.conf

# 输入
appendonly yes

# 重启
docker restart redis

进入redis客户端

docker exec -it redis redis-cli

docker安装Nginx

1、安装 nginx，随便启动一个 nginx 容器，只是为了把配置文件复制出来，否则直接启动容器可能直接停止

docker run -p 80:80 --name nginx -d nginx

docker ps

2、将容器内的配置文件拷贝出来

# 在 /mydata 目录下新建 nginx 目录
cd /mydata
mkdir nginx

docker container cp nginx:/etc/nginx . # 别忘了后面的 .

# 拷贝出来后，停止容器，删除容器
docker stop nginx
docker rm nginx

# 切换到 /mydata 目录，将 nginx 目录重命名为 conf
cd /mydata
mv nginx conf

# 再新建一个 nginx 目录，将 conf 目录放进去
mkdir nginx
mv conf nginx/

3、创建新的 nginx，执行以下命令

docker run -p 80:80 --name nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \
-v /mydata/nginx/logs/:/var/log/nginx \
-v /mydata/nginx/conf:/etc/nginx \
-d nginx

docker安装elasticsearch和kibana

版本要统一

# 存储和检索数据
docker pull elasticsearch:7.4.2

# 可视化检索数据
docker pull kibana:7.4.2

# 查看可用内存
free -m

elasticsearch

# 创建挂载目录
mkdir -p /mydata/elasticsearch/config
mkdir -p /mydata/elasticsearch/data

# 赋予权限，保证可读可写可执行
chmod -R 777 /mydata/elasticsearch/

# 可以被远程任何机器访问
echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

# 创建并运行容器
# 9200 是发送 http 请求的端口
# 9300 是在分布式集群状态下节点之间的通信端口
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data/:/usr/share/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2

如果容器没有启动起来使用以下命令查看日志，看看有没有报错

docker logs 容器名/容器id

Kibana

为了方便，还是安装可视化工具

# http://192.168.56.10:9200 为自己的ELASTICSEARCH地址
docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.56.10:9200 -p 5601:5601 -d kibana:7.4.2

页面访问5601端口即可

docker安装RabbitMQ

docker run -d --name rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p  25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:3-management

# 4369, 25672 (Erlang发现&集群端口)
# 5672, 5671 (AMQP端口)
# 15672 (web管理后台端口)
# 61613, 61614 (STOMP协议端口)
# 1883, 8883 (MQTT协议端口)

# 设置开启自动启动容器
docker update rabbitmq --restart=always

# 设置开机不自动启动
docker update 容器id/容器名 --restart=no

访问： 你的ip地址:15672 ，账号密码默认都是 guest

docker下安装kafka和kafka-manager

下载镜像

这里使用了 wurstmeister/kafka 和 wurstmeister/zookeeper 这两个版本的镜像

docker pull wurstmeister/zookeeper
docker pull wurstmeister/kafka
docker pull sheepkiller/kafka-manager

在命令中运行 docker images 验证三个镜像已经安装完毕

运行容器

启动zookeeper

docker run -d --name zookeeper --publish 2181:2181 \
--volume /etc/localtime:/etc/localtime \
--restart=always \wurstmeister/zookeeper

启动kafka

docker run -d --name kafka --publish 9092:9092 \
--link zookeeper:zookeeper \
--env KAFKA_BROKER_ID=100 \
--env HOST_IP=192.168.56.111 \
--env KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 \
--env KAFKA_ADVERTISED_HOST_NAME=192.168.56.111 \
--env KAFKA_ADVERTISED_PORT=9092 \
--restart=always \
--volume /etc/localtime:/etc/localtime \
wurstmeister/kafka

启动kafka-manager

docker run -d --name kafka-manager \
--link zookeeper:zookeeper \
--link kafka:kafka -p 9001:9000 \
--restart=always \
--env ZK_HOSTS=zookeeper:2181 \
sheepkiller/kafka-manager

访问kafkamanager， http://ip:9001

基本命令

# 进入容器
docker exec -it kafka /bin/bash
# 创建一个名为 test 的 Topic，该 Topic 包含一个分区和一个 Replica


# 进入kafka容器执行
kafka-topics.sh \
--create \
--zookeeper 192.168.56.111:2181 \
--replication-factor 1 \
--partitions 1 \
--topic test
Created topic test

# Topic查询
kafka-topics.sh --list \
--zookeeper 192.168.56.111:2181

# 命令行消息生产者创建
kafka-console-producer.sh \
--broker-list 192.168.56.111:9092 \
--topic test

#命令行消息消费者创建
kafka-console-consumer.sh \
--bootstrap-server 192.168.56.111:9092 \
--topic test \
--from-beginning

# Topic删除
kafka-topics.sh \
--zookeeper 192.168.56.111:2181 \
--delete \
--topic test

# 查看消费者
kafka-consumer-groups.sh \
--bootstrap-server 192.168.56.111:9092 \
--list

# 查看消息内容
kafka-console-consumer.sh \
--bootstrap-server 192.168.56.111:9092 \
--topic test \
--from-beginning

# 指定消费组消费
kafka-console-consumer.sh \
--bootstrap-server 192.168.56.111:9092 \
--topic test1 \
--consumer-property group.id=test_groupId

# 查看kafka消费者 偏移量 与 积压
kafka-consumer-groups.sh \
--bootstrap-server 192.168.56.111:9092 \
--describe --group test_groupId123

安装Clickhouse

单机安装ClickHouse

docker环境搭建好以后，利用docker安装clickhouse比较简单，clickhouse官方提供了默认的镜像，直接使用即可。

官方文档参考：点我跳转

拉取clickhouse的docker镜像

 docker pull yandex/clickhouse-server
 docker pull yandex/clickhouse-client

启动server端

# 默认直接启动即可
 docker run -d --name [启动之后的名称] --ulimit nofile=262144:262144 yandex/clickhouse-server
 ​
 # 如果想指定目录启动，这里以clickhouse-test-server命令为例，可以随意写
 # 创建数据文件目录
 mkdir /work/clickhouse/clickhouse-test-db      
 # 使用以下路径启动，在外只能访问clickhouse提供的默认9000端口，只能通过clickhouse-client连接server
 docker run -d \
 --name clickhouse-test-server \
 --ulimit nofile=262144:262144 \
 --volume=/mydata/clickhouse/clickhouse_test_db:/var/lib/clickhouse yandex/clickhouse-server

启动并连接clickhouse-server

docker启动clickhouse-client

docker run -it --rm --link clickhouse-test-server:clickhouse-server yandex/clickhouse-client --host clickhouse-server

客户端常用参数

clickhouse-client
     --host, -h     # 服务端host名称，默认 localhost
     --port         # 连接端口，默认9000
     --user, -u     # 用户名，默认 default
     --password     # 密码，默认空
     --query, -q   # 非交互模式下的查询语句
     --database, -d # 默认当前操作的数据库，默认default
     --multiline, -m # 允许多行语句查询，在clickhouse中默认回车即为sql结束，可使用该参数多行输入
     --format, -f # 使用指定的默认格式输出结果     csv,以逗号分隔
     --time, -t # 非交互模式下会打印查询执行的时间
     --stacktrace # 出现异常会打印堆栈跟踪信息
     --config-file # 配置文件名称

集群安装ClickHouse

服务器准备

这里我们准备三台服务器，可以使用 Vagrant 创建三台虚拟机。

分别配置 hostname 为server01、server02、server03

所有的服务器的 /etc/hosts 都加上以下配置

 $ip1 server01
 $ip2 server02
 $ip3 server03

其中，$ip1、$ip2、$ip3代表的是你三台服务器的ip，记得以实际值写入到 /etc/hosts 文件中

拉取镜像

 yum pull docker.io/yandex/clickhouse-server
 yum pull docker.io/yandex/clickhouse-client

安装Zookeeper集群

1、安装jdk

使用rpm方式安装即可。

2、zookeeper安装与配置

下载地址： http://archive.apache.org/dist/zookeeper/zookeeper-3.5.8/ 上传到linux

假定zookeeper安装在三台机器：192.168.56.100 、192.168.56.101 、192.168.56.102

解压文件，创建存放目录，每台机器都要操作

 # 解压文件
 tar -zxvf apache-zookeeper-3.5.8-bin.tar.gz
 # 创建zookeeper存放数据目录
 mkdir -p /mydata/zookeeper/data

修改配置文件，每台机器都要设置

 #进入配置文件目录，复制样例配置文件
 cd /mydata/apache-zookeeper-3.5.8-bin/conf
 cp zoo_sample.cfg zoo.cfg
 
  #编辑配置文件，修改或添加如下内容
 vi zoo.cfg
 
 dataDir=/mydata/zookeeper/data
 clientPort=2181
 server.0=192.168.56.100:2888:3888
 server.1=192.168.56.101:2888:3888
 server.2=192.168.56.102:2888:3888

创建myid文件，每台机器都要设置

 # 创建myid文件，在对应主机按照zoo.cfg文件中写上相应配置数字进行编辑
 cd /mydata/zookeeper/data
 vi myid  
 # 输入以下内容，每台机器的myid不能重复，比如这里是0，
 # 其他两台设置为1和2,和上面server.x的x对应
 0

配置环境变量

 # 进入到 /etc/profile 目录，添加相应的配置信息：
 export ZK_HOME=/mydata/apache-zookeeper-3.5.8-bin
 export PATH=$PATH:$ZK_HOME/bin
 #然后通过如下命令使得环境变量生效：
 source /etc/profile

启动zookeeper

 # 启动命令：
 zkServer.sh start
 # 停止命令：
 zkServer.sh stop
 # 重启命令：
 zkServer.sh restart
 # 查看集群节点状态：
 zkServer.sh status

执行完毕后，分别查看集群节点状态，三台机器，slave1成功的通过了选举称为了leader,而剩下的两台成为了follower。这时候，如果你将slave1关掉，会发现剩下两台又会有一台变成了leader节点。

后续参考文章： https://juejin.cn/post/6844903826781110280

安装docker-compose

curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

Docker安装 Nacos

1、拉取nacos-server镜像

docker pull nacos/nacos-server

2、创建文件

mkdir -p /mydata/nacos/init.d
cd /mydata/nacos/init.d
vim custom.properties

/mydata/nacos/init.d/custom.properties 配置如下

management.endpoints.web.exposure.include=*

3、启动docker

docker run -d -p 8848:8848 \
-e MODE=standalone \
-v /mydata/nacos/init.d/custom.properties:/home/nacos/init.d/custom.properties \
-v /mydata/nacos/logs:/home/nacos/logs \
--name nacos nacos/nacos-server:latest

访问 http://ip:8848/nacos/index.html#/login

账号密码： nacos/nacos

Docker启动nginxWebUI

这是一个开源的nginx可视化配置后台

docker run -itd \
-v /mydata/nginxWebUI:/home/nginxWebUI \
-e BOOT_OPTIONS="--server.port=38888" \
--privileged=true \
--net=host \
cym1102/nginxwebui:latest /bin/bash

Docker安装使用MongoDB

安装

docker run --name mongo \
-p 27017:27017 \
-v /mydata/mongodb/db:/data/db \
-v /mydata/mongodb/configdb:/data/configdb \
-e MONGO_INITDB_ROOT_USERNAME=admin \
-e MONGO_INITDB_ROOT_PASSWORD=admin \
-d mongo

登录到mongo的容器里

docker exec -it mongo bash

使用交互的形式, 在名字为 mongodb 的容器中实行 bash这个命令

连接mongo

mongo -u admin -p admin

使用

在容器中连接

新建数据库abc，添加用户baby，密码123456，授权readWrite，在abc上添加一条数据

> use abc;
switched to db abc
>  db.createUser({user:"baby",pwd:"123456",roles:["readWrite"]})
Successfully added user: { "user" : "baby", "roles" : [ "readWrite" ] }
> show users
{
        "_id" : "abc.baby",
        "userId" : UUID("bde1abcc-e351-4e16-95c7-786e2f9a7f60"),
        "user" : "baby",
        "db" : "abc",
        "roles" : [
                {
                        "role" : "readWrite",
                        "db" : "abc"
                }
        ],
        "mechanisms" : [
                "SCRAM-SHA-1",
                "SCRAM-SHA-256"
        ]
}
> show databases
admin   0.000GB
config  0.000GB
local   0.000GB
> db.abc.insert({"name":"joe","age":"20"})
WriteResult({ "nInserted" : 1 })
> show databases
abc     0.000GB
admin   0.000GB
config  0.000GB
local   0.000GB
> db.abc.find({"name":"joe"})
{ "_id" : ObjectId("5e8d5ea9b116039555a29399"), "name" : "joe", "age" : "20" }

在windows上连接

可以下载mongodb的windows版本，然后添加环境变量

mongo  宿主机ip/数据库  -u用户名 -p密码

D:\mongodb\bin>mongo 192.168.99.100/abc -u baby -p 123456
MongoDB shell version v4.2.0
connecting to: mongodb://192.168.99.100:27017/abc?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("c1b84b1a-b94c-48d1-ac87-0c061d63a62e") }
MongoDB server version: 4.2.5
> show databases
abc  0.000GB
> db.abc.find({"name":"joe"})
{ "_id" : ObjectId("5e8d5ea9b116039555a29399"), "name" : "joe", "age" : "20" }

Docker安装使用Neo4j

拉取镜像

第一步，从镜像源中找合适的镜像

docker search neo4j

第二步，拉取镜像源

docker pull neo4j(:版本号) // 缺省 “:版本号” 时默认安装latest版本的

第三步，查看本地镜像，检验是否拉取成功

docker images

构建Neo4j容器

第一步，在你根目录的任意一个子目录（我这里是/mydata)下建立四个基本的文件夹

• data——数据存放的文件夹
• logs——运行的日志文件夹
• conf——数据库配置文件夹（在配置文件neo4j.conf中配置包括开放远程连接、设置默认激活的数据库）
• import——为了大批量导入csv来构建数据库，需要导入的节点文件nodes.csv和关系文件rel.csv需要放到这个文件夹下）

docker run -d --name neo4j \
	-p 7474:7474 -p 7687:7687 \
	-v /mydata/neo4j/data:/data \
	-v /mydata/neo4j/logs:/logs \
	-v /mydata/neo4j/conf:/var/lib/neo4j/conf \
	-v /mydata/neo4j/import:/var/lib/neo4j/import \
	--env NEO4J_AUTH=用户名/密码 \
	neo4j

执行完上述命令后就在后台把neo4j容器启动起来了，这个时候你就能在宿主机的浏览器中输入

虚拟机ip:7474

输入用户名和密码就能登录到数据库了。

Neo4j配置

上述方式启动的neo4j是按照默认的配置进行启动的，而默认的数据库配置是不允许远程登陆的，这样对于在服务器上使用docker搭载neo4j的同学来说，就很不方便了。所以我们对默认配置进行一些改变，改变如下：

# 进入容器配置目录挂载在宿主机的对应目录，我这里是/home/neo4j/conf
cd /mydata/neo4j/conf

# vim编辑器打开neo4j.conf
vim neo4j.conf

# 进行以下更改
# 在文件配置末尾添加
# 指定连接器的默认监听ip为0.0.0.0，即允许任何ip连接到数据库
dbms.connectors.default_listen_address=0.0.0.0  
dbms.connector.bolt.listen_address=0.0.0.0:7687
dbms.connector.http.listen_address=0.0.0.0:7474  

防火墙设置

一、防火墙的开启、关闭、禁用命令

#（1）设置开机启用防火墙：
systemctl enable firewalld.service
#（2）设置开机禁用防火墙：
systemctl disable firewalld.service
#（3）启动防火墙：
systemctl start firewalld
#（4）关闭防火墙：
systemctl stop firewalld
#（5）检查防火墙状态：
systemctl status firewalld 

#（1）查看防火墙状态：
firewall-cmd --state
#（2）重新加载配置：
firewall-cmd --reload
#（3）查看开放的端口：
firewall-cmd --list-ports
#（4）开启防火墙端口：
firewall-cmd --zone=public --add-port=9200/tcp --permanent
#（5）关闭防火墙端口：
firewall-cmd --zone=public --remove-port=9200/tcp --permanent
#　命令含义：

#　　–zone #作用域

#　　–add-port=9200/tcp #添加端口，格式为：端口/通讯协议

#　　–permanent #永久生效，没有此参数重启后失效

#　　注意：添加端口后，必须用命令firewall-cmd --reload重新加载一遍才会生效