docker 部署mysql详细过程(docker部署常见应用)（docker 部署 mysql）

25-02-07 17

如果您想了解docker部署mysql详细过程(docker部署常见应用)的相关知识，那么本文是一篇不可错过的文章，我们将对docker部署mysql进行全面详尽的解释，并且为您提供关于docker(

如果您想了解docker 部署mysql详细过程(docker部署常见应用)的相关知识，那么本文是一篇不可错过的文章，我们将对docker 部署 mysql进行全面详尽的解释，并且为您提供关于docker (部署常见应用)：docker 部署 redis、Docker 常见应用部署、docker 微服务部署之：四、安装 docker、docker 中安装 mysql 和 jdk1.8、手动构建镜像、部署项目、Docker 部署MySQL的有价值的信息。

本文目录一览：

docker 部署mysql详细过程(docker部署常见应用)（docker 部署 mysql）
docker (部署常见应用)：docker 部署 redis
Docker 常见应用部署
docker 微服务部署之：四、安装 docker、docker 中安装 mysql 和 jdk1.8、手动构建镜像、部署项目
Docker 部署MySQL

docker 部署mysql详细过程(docker部署常见应用)（docker 部署 mysql）

之前给大家介绍过：docker(部署常见应用)：docker部署nginx

docker部署mysql:5.7.26

# 下载镜像
docker pull mysql:5.7.26

# 查看镜像
docker images|grep mysql

# 启动容器镜像，建议在/usr/local/workspace/mysql  下执行以下docker  run  命令
  docker run -p 13306:3306 --name my-mysql -v $PWD/conf:/etc/mysql -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.26
 
  # 建议写死路径
  docker run -p 13306:3306 --name my-mysql -v /usr/local/workspace/mysql/conf:/etc/mysql -v /usr/local/workspace/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.26

命令说明：

-p 13306:3306 　　　　　　　　　　　将容器的 3306 端口映射到主机的 3306 端口

--name my-mysql 　　　　　　　　　　启动后容器名为my-mysql

-v $PWD/conf:/etc/mysql 　　　　　　　　将主机当前目录下的 conf/ 挂载到容器的 /etc/mysql （conf目录为mysql的配置文件，不挂载也没问题）

-v $PWD/logs:/logs　　　　　　　　　　　　　　　将主机当前目录下的 logs 目录挂载到容器的 /logs （logs目录为mysql的日志目录，不挂载也没影响）

-v $PWD/data:/var/lib/mysql　　　　　　　　　　　将主机当前目录下的data目录挂载到容器的 /var/lib/mysql （data目录为mysql配置的数据文件存放路径，这个还是建议挂载，是存储数据的，容器down掉，还能再次挂载数据。）

-e MYSQL_ROOT_PASSWORD=123456　　　　初始化 root 用户的密码

查看容器启动情况

[xxx@xxx-xx-xxx  mysql]# docker ps|grep mysql
5291ed3fe987        mysql:5.7.26                                        "docker-entrypoint.s??   5 minutes ago       Up 5 minutes        33060/tcp, 0.0.0.0:13306->3306/tcp   my-mysql

进入mysql容器

# 登录容器[root@cbov10-sso55-xxx ~]# docker exec -it my-mysql bash
root@5291ed3fe987:/# ls
bin   dev              entrypoint.sh  home  lib64  media  opt   root  sbin  sys  usr
boot  docker-entrypoint-initdb.d  etc         lib   logs   mnt    proc  run     srv   tmp  var
# 登录mysqlroot@5291ed3fe987:/# mysql -uroot -p --default-character-set=utf8
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.26 MySQL Community Server (GPL)

Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type ''help;'' or ''\h'' for help. Type ''\c'' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

设置能远程登录mysql

mysql> use mysql
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> select host,user from user;
+-----------+---------------+
| host      | user          |
+-----------+---------------+
| %         | root          |
| localhost | mysql.session |
| localhost | mysql.sys     |
| localhost | root          |
| localhost | test          |
+-----------+---------------+
5 rows in set (0.00 sec)

# 设置root用户在任何地方进行远程登录，并具有所有库任何操作权限，（公司绝对不能这么做，暴露的攻击面太大），这里只是做测试。
mysql> GRANT ALL PRIVILEGES ON *.* TO ''root''@''%'' IDENTIFIED BY ''123456'' WITH GRANT OPTION;
Query OK, 0 rows affected, 1 warning (0.00 sec)

# 刷新权限
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

# 退出mysql 
mysql> exit
Bye

关于mysql授权，各位可自行百度，这里推荐

mysql之权限管理

Mysql权限控制

远程登录测试

使用数据库连接工具连接宿主机ip+宿主机暴露的端口。

前面我们启动容器的时候-p13306:3306 标识宿主机端口 13306 映射到容器的 3306 ，假如我们宿主机，就是服务器的ip地址为10.10.10.11

应该连接 10.10.10.11:13306 连接的数据库这里推荐新建test 数据库做测试，如下

docker ，mysql重启问题（数据会不会丢失？）

# 查看容器
[root@cbov10-sso55-113 mysql]# docker ps|grep mysql
5291ed3fe987        mysql:5.7.26                                        "docker-entrypoint.s??   4 hours ago         Up 4 hours          33060/tcp, 0.0.0.0:13306->3306/tcp   my-mysql

# 停止容器 （ 5291ed3fe987 这里是mysql容器id）
[root@cbov10-sso55-113 mysql]# docker stop 5291ed3fe987
5291ed3fe987


# 删除容器
[root@cbov10-sso55-113 mysql]# docker rm 5291ed3fe987
5291ed3fe987

去我们原先挂载目录下查看

挂载宿主机目录是 /usr/local/workspace/mysql，

[root@cbov10-sso55-xxx mysql]# cd data/
[root@cbov10-sso55-xxx data]# ls
auto.cnf    ca.pem           client-key.pem  ibdata1      ib_logfile1  performance_schema  public_key.pem   server-key.pem  test
ca-key.pem  client-cert.pem  ib_buffer_pool  ib_logfile0  mysql        private_key.pem     server-cert.pem  sys

数据文件还在！我们再重新执行

# 这里要注意和挂载的宿主机目录一定要一致，第一次在 /usr/local/workspace/mysql 下执行的命令，这次也应该在同目录

# 当然，写成固定路径就没有上面的问题

[root@cbov10-sso55-xxx mysql]#   docker run -p 13306:3306 --name my-mysql -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.26
74c91431533ebb9bbfd3a1123b3f910f54770a08ad08c3c37cbbb996d29e0428

# 这里可以看出容器id已经发生了变化
[root@cbov10-sso55-xxx mysql]# docker ps |grep mysql
74c91431533e        mysql:5.7.26                                        "docker-entrypoint.s??   16 seconds ago      Up 15 seconds       33060/tcp, 0.0.0.0:13306->3306/tcp   my-mysql

# 进入容器
[root@cbov10-sso55-xxx mysql]# docker exec -it bash 74c91431533e
Error: No such container: bash
[root@cbov10-sso55-xxx mysql]# docker exec -it  74c91431533e bash
root@74c91431533e:/# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.26 MySQL Community Server (GPL)

Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type ''help;'' or ''\h'' for help. Type ''\c'' to clear the current input statement.


mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| test               |
+--------------------+
5 rows in set (0.00 sec)

发现建的test数据库也在！mysql容器删除前后，data文件大小也可以验证，读者壳自行尝试。

宿主机文件保存好的话，数据可以不丢失。

说明：

其实生产比做的这个测试要复杂的多，mysql集群，主备，数据同步，网络等等问题，用docker解决确实为难

mysql 容器的管理或者说，有状态应用的管理还得一个比较流弊的东西，这个项目是大名鼎鼎的kubernetes。

docker 部署 redis:4.0

# 下载镜像
docker pull redis:4.0

# 查看下载镜像
docker images|grep redis

# 启动镜像

docker run --name my-redis -p 16379:6379 -v /usr/local/workspace/redis/data:/data -d redis:4.0 redis-server --appendonly yes

命令说明：

--name my-redis 　　　　　　　　　　启动后容器名为 my-redis

-p 16379:3306 　　　　　　　　　　　将容器的 3306 端口映射到主机的 16379 端口

-v /usr/local/workspace/redis/data:/data 将主机 /usr/local/workspace/redis/data 目录挂载到容器的 /data

redis-server --appendonly yes　　　　在容器执行 redis-server 启动命令，并打开 redis 持久化配置

查看容器启动情况

[root@k8s-master docker]# docker ps|grep redis
f9eb2360ed36        redis:4.0           "docker-entrypoint.s??   5 minutes ago       Up 5 minutes        0.0.0.0:16379->6379/tcp              my-redis

进入 redis 容器

# 进入redis容器
docker exec -it f9eb2360ed36 bash

# 找到redis执行脚本
root@f9eb2360ed36:/usr/local/bin# cd /usr/local/bin/

root@f9eb2360ed36:/usr/local/bin# ls -l
total 24528
-rwxrwxr-x 1 root root      374 Jun 11 06:46 docker-entrypoint.sh
-rwxr-xr-x 1 root staff 1286720 May 24  2017 gosu
-rwxr-xr-x 1 root staff 2628640 Jun 11 06:48 redis-benchmark
-rwxr-xr-x 1 root staff 6121232 Jun 11 06:48 redis-check-aof
-rwxr-xr-x 1 root staff 6121232 Jun 11 06:48 redis-check-rdb
-rwxr-xr-x 1 root staff 2820088 Jun 11 06:48 redis-cli
lrwxrwxrwx 1 root staff      12 Jun 11 06:48 redis-sentinel -> redis-server
-rwxr-xr-x 1 root staff 6121232 Jun 11 06:48 redis-server

# 执行redis-cli命令连接到redis中
root@f9eb2360ed36:/usr/local/bin# ./redis-cli 

# 展示redis信息 
127.0.0.1:6379> info
# Server
redis_version:4.0.14
redis_git_sha1:00000000
redis_git_dirty:0

感谢支持。感谢观看

Docker 常见应用部署

一、部署MySQL

搜索mysql镜像

docker search mysql

拉取mysql镜像

docker pull mysql:5.6

# 在/root目录下创建mysql目录用于存储mysql数据信息
mkdir ~/mysql
cd ~/mysql

docker run -id \
-p 3306:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.6

参数说明：
- $PWD：表示当前目录所在路径，现在表示/root/mysql。
- -p 3306:3306：将容器的 3306 端口映射到宿主机的 3306 端口。
- -v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
- -v $PWD/logs:/logs：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
- -v $PWD/data:/var/lib/mysql ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
- -e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。
- 创建容器后会自动启动mysql服务，直接使用即可。

进入容器，操作mysql。

docker exec –it c_mysql /bin/bash

使用外部机器连接容器中的mysql。

二、部署Tomcat

搜索tomcat镜像

docker search tomcat

拉取tomcat镜像

docker pull tomcat

# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat

docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat

参数说明：
- -p 8080:8080：将容器的8080端口映射到主机的8080端口
- -v $PWD:/usr/local/tomcat/webapps：将主机中当前目录挂载到容器的webapps
- 创建容器后会自动自动tomcat服务，直接使用即可。

使用外部机器访问tomcat

三、部署Nginx

搜索nginx镜像

docker search nginx

拉取nginx镜像

docker pull nginx

# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容(nginx官网默认的配置文件)
vim nginx.conf


user  nginx;
worker_processes  1;

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;

    keepalive_timeout  65;

    #gzip  on;

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

docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx

参数说明：
- -p 80:80：将容器的 80端口映射到宿主机的 80 端口。
- -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
- -v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录
- 创建容器后会自动启动nginx服务，直接使用即可。

使用外部机器访问nginx

四、部署Redis

搜索redis镜像

docker search redis

拉取redis镜像

docker pull redis:5.0

创建容器，设置端口映射

docker run -id --name=c_redis -p 6379:6379 redis:5.0

使用外部机器连接redis

五、部署Anaconda

拉取anaconda镜像

# 安装python3版本的
docker pull continuumio/anaconda3

创建容器，设置端口映射

docker run -it --name=anaconda -p 8888:8888 continuumio/anaconda3

参数说明：

-p 8888:8888：将宿主机的8888端口和容器8888端口进行映射
-it：启动后即进入容器终端

在容器中启动jupyter notebook服务

jupyter notebook --ip=0.0.0.0 --allow-root

参数说明：

--ip=0.0.0.0：允许任何用户访问
--allow-root：允许以root用户启动服务，因为当前例子是以root用户登录的，没有这句会报错

复制命令行中的地址，用浏览器访问

docker 微服务部署之：四、安装 docker、docker 中安装 mysql 和 jdk1.8、手动构建镜像、部署项目

docker 微服务部署之：三，搭建 Zuul 微服务项目

1.Centos7 安装 Docker

详见：Centos7 安装 Docker

2.Docker 中安装 jdk1.8

详见：使用 Docker 构建 jdk1.8

3.Docker 中安装 mysql5.7

详见：docker 安装 mysql

在防火墙中开启 3306 端口，不然启动 article 项目连接 docker 中的 mysql 时，会报如下错误：

Caused by: com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure

The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.

查看端口是否开启，开启端口以及移除指定端口命令如下：

#查看是否开启指定端口
$ sudo firewall-cmd --query-port=3306/tcp
no
#添加指定需要开放的端口
$ sudo firewall-cmd --add-port=3306/tcp --permanent
success
#移除指定端口
#firewall-cmd --permanent --remove-port=3306/tcp
#重新载入添加/移除的端口
$ sudo firewall-cmd --reload
#也可再查下是否开启指定端口
$ sudo firewall-cmd --query-port=3306/tcp
yes

4. 部署 demo_eureka 项目

我的虚拟机的 ip 地址为：192.168.31.181

4.1 把 demo_eureka 项目打成 jar 包

4.1.1 打包前，修改项目配置

在打包之前，需要在 demo_eureka 项目中修改如下几个地方：

修改 pom.xml，新增如下内容：

<build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

修改 application.yml 中如下内容

#defaultZone: http://127.0.0.1:${server.port}/eureka
     #192.168.31.181为虚拟机的IP地址
      defaultZone: http://192.168.31.181:${server.port}/eureka

4.1.2 将 demo_eureka 项目打成 app.jar

将 demo_eureka 项目以及后面的 demo_article 项目、demo_zuul 项目都打成 app.jar，是因为方便利用 Dockerfile 部署时方便。

点击 idea 窗体左小角的 Terminal，然后将项目 demo_eureka 拖动到 Terminal 窗体里，接着输入 mvn clean package，如图：

刷新 target 目录，即可在该目录下看到 app.jar。

4.1.3 防火墙开启 7000 端口 (7000 端口为 demo_eureka 项目中自定义的 server.port 端口号)

如果没有开启 7000 端口，article 服务和 zuul 服务，会注册不到 eureka 上来。

#查看是否开启指定端口
$ sudo firewall-cmd --query-port=7000/tcp
no
#添加指定需要开放的端口
$ sudo firewall-cmd --add-port=7000/tcp --permanent
success
#移除指定端口
#firewall-cmd --permanent --remove-port=7000/tcp
#重新载入添加/移除的端口
$ sudo firewall-cmd --reload
#也可再查下是否开启指定端口
$ sudo firewall-cmd --query-port=7000/tcp
yes

4.1.4 docker 构建 eureka 镜像，创建并运行 eureka 容器、查看 eureka 容器运行日志

a. 构建镜像前的准备工作：

# 创建用于存放app.jar和Dockerfile文件的目录，取名为mydocker
$ sudo mkdir /usr/local/mydocker
$ sudo cd /usr/local/mydocker
# 将app.jar上传到该目录（/usr/local/mydocker/）
# 创建Dockerfile文件，文件名必须一模一样
$ sudo vi Dockerfile
# 基于jdk1.8镜像构建eureka镜像（因为eureka是打成了jar是通过java -jar来运行）
FROM jdk1.8
# 将当前目录的app.jar，复制到eureka镜像的/目录，名为app.jar
ADD app.jar /app.jar
# 之所以用ENTRYPOINT命令，而不是CMD命令，是因为docker run会覆盖掉CMD命令里的内容。该行命令，就是执行java -jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

b. 构建 eureka 镜像

# eureka为构建后的镜像名称，下面最后的.和.前面的空格一定不能少。最后的.表示使用当前目录中的Dockerfile来构建。
$ sudo docker build -t eureka .
Sending build context to Docker daemon  46.05MB
Step 1/3 : FROM jdk1.8
 ---> 1f2578d93bd0
Step 2/3 : ADD app.jar /app.jar
 ---> 14d818fa91b0
Step 3/3 : ENTRYPOINT ["java","-jar","/app.jar"]
 ---> Running in d421e50bf8cd
Removing intermediate container d421e50bf8cd
 ---> 15c87bf6f8e5
Successfully built 15c87bf6f8e5
Successfully tagged eureka:latest
# 上面输出Successfully...表示构建eureka镜像成功,也可通过docker images命令查看是否构建成功
$ sudo docker images
REPOSITORY                TAG                 IMAGE ID            CREATED             SIZE
eureka                    latest              15c87bf6f8e5        51 seconds ago      645MB
...
# 上面可以看到REPOSITORY下有一个名为eureka的镜像，即表示构建成功

c. 运行 eureka 容器

# docker run 表示创建一个新的容器并运行
# -d 表示以守护模式运行，也就是后台运行，非阻塞式运行
# --name=eureka 表示运行后的容器名称为eureka
# -p 7000:7000 表示将宿主机的7000端口和eureka容器的7000之间做个绑定
# 最后的eureka，是docker images中查看到的镜像名称
$ sudo docker run -d --name=eureka -p 7000:7000 eureka
0af7b3701b59048f9f9a901b29aff31b9956b2391c3d299f7e5f6016c8c44ffb
#出现如上一个很长的字符串，表示运行docker创建了一个eureka容器，并运行eureka容器成功，但至于eureka容器中的eureka服务是否能和我们预期的那么部署成功，还待下一步验证

d. 验证 eureka 服务

首先查看 eureka 容器是否在运行中

#查看运行中的容器(后面加 -a 可查看所有容器，不管该容器是否在运行中)
$ sudo docker ps
CONTAINER ID        IMAGE                     COMMAND                  CREATED             STATUS              PORTS                    NAMES
0af7b3701b59        eureka                    "java -jar /app.jar"     17 minutes ago      Up 17 minutes       0.0.0.0:7000->7000/tcp   eureka

可通过两种方式验证：

1. 通过浏览器访问 eureka 服务地址，是否能看到 eureka 界面

2. 通过查看运行日志

# docker logs 查看docker容器运行日志
# -f --tail=30 一直查看最后30行的日志
# eureka 容器的名称
$ sudo docker logs -f --tail=30 eureka

5. 部署 demo_article 项目

5.1 把 demo_article 项目打成 jar 包

5.1.1 打包前，修改项目配置

在打包之前，需要修改 demo_article 项目中修改如下几个地方：

修改 pom.xml，新增如下内容：

   <build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

修改 application.yml 中相应部分内容为如下：

...
    url: jdbc:mysql://192.168.31.181:3306/docker?characterEncoding=UTF8
  ...
      defaultZone: http://192.168.31.181:7000/eureka
  ...

5.1.2 将 demo_article 项目打成 app.jar

点击 idea 窗体左小角的 Terminal，然后将项目 demo_article 拖动到 Terminal 窗体里，接着输入 mvn clean package，回车，刷新 target 目录，即可在该目录下看到 app.jar。

5.1.3 防火墙开启 9001 端口 (9001 端口为 demo_article 项目中自定义的 server.port 端口号)

如果没有开启 9001 端口，会出现 demo_article 项目在 article 容器中启动成功，但是无法访问 article 服务。

#查看是否开启指定端口
$ sudo firewall-cmd --query-port=9001/tcp
no
#添加指定需要开放的端口
$ sudo firewall-cmd --add-port=9001/tcp --permanent
success
#移除指定端口
#firewall-cmd --permanent --remove-port=9001/tcp
#重新载入添加/移除的端口
$ sudo firewall-cmd --reload
#也可再查下是否开启指定端口
$ sudo firewall-cmd --query-port=9001/tcp
yes

5.1.4 docker 构建 article 镜像、创建和运行 article 容器、查看 article 容器运行日志

a. 构建镜像前的准备工作

$ sudo cd /usr/local/mydocker
# 将app.jar上传到该目录（/usr/local/mydocker/）
$ sudo ls
app.jar Dockerfile

因为在构建 eureka 镜像时，已经创建了一个用于存放 jar 包和 Dockerfile 的目录叫 mydocker，所以不用再创建。

另外，由于不管是哪个项目，都打包成了名为 app.jar，所以 Dockerfile 文件也可以复用。

故只需要把 demo_article 打成的 jar 包，上传到 /usr/local/mydocker 目录下，覆盖掉原先的 app.jar 即可。

b. 构建 article 镜像

# article为构建后的镜像名称，下面最后的.和.前面的空格一定不能少。最后的.表示使用当前目录中的Dockerfile来构建。
$ sudo docker build -t article .
Sending build context to Docker daemon  46.05MB
Step 1/3 : FROM jdk1.8
 ---> 1f2578d93bd0
Step 2/3 : ADD app.jar /app.jar
 ---> 9633e0cb462b
Step 3/3 : ENTRYPOINT ["java","-jar","/app.jar"]
 ---> Running in a51dd9b611e6
Removing intermediate container a51dd9b611e6
 ---> 7f5954f085f6
Successfully built 7f5954f085f6
Successfully tagged eureka:latest
# 上面输出Successfully...表示构建article镜像成功,也可通过docker images命令查看是否构建成功
$ sudo docker images
REPOSITORY                TAG                 IMAGE ID            CREATED             SIZE
article                    latest              7f5954f085f6        2 minutes ago      651MB
...
# 上面可以看到REPOSITORY下有一个名为article的镜像，即表示构建成功

c. 运行 article 容器

# docker run 表示创建一个新的容器并运行
# -d 表示以守护模式运行，也就是后台运行，非阻塞式运行
# --name=article 表示运行后的容器名称为article
# -p 9001:9001 表示将宿主机的9001端口和eureka容器的9001之间做个绑定
# 最后的eureka，是docker images中查看到的镜像名称
$ sudo docker run -d --name=article -p 9001:9001 article
7031e9a5bd25d2708e18b8b986ae3081c09bb29caa4948fd437e7b5a9b47c602
#出现如上一个很长的字符串，表示运行docker创建了一个article容器，并运行article容器成功，但至于article容器中的article服务是否能和我们预期的那么部署成功，还待下一步验证

d. 验证 article 服务

首先查看 article 容器是否在运行中

#查看运行中的容器(后面加 -a 可查看所有容器，不管该容器是否在运行中)
$ sudo docker ps
CONTAINER ID        IMAGE                     COMMAND                  CREATED              STATUS              PORTS                    NAMES
7031e9a5bd25        article                   "java -jar /app.jar"     About a minute ago   Up About a minute   0.0.0.0:9001->9001/tcp   article

可通过三种方式验证：

1. 通过浏览器访问 eureka 服务地址，查看 demo_article 服务是否注册到 eureka 上

2. 通过查看运行日志

# docker logs 查看docker容器运行日志
# -f --tail=30 一直查看最后30行的日志
# article 容器的名称
$ sudo docker logs -f --tail=30 article

3. 通过访问 demo_article 项目的 url

6. 部署 demo_zuul 项目

6.1 把 demo_zuul 项目打成 jar 包

6.1.1 打包前，修改项目配置

在打包之前，需要修改 demo_zuul 项目中修改如下几个地方：

修改 pom.xml，新增如下内容：

<build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

修改 application.yml 中相应部分内容为如下：

...
    defaultZone: http://192.168.31.181:7000/eureka
...

6.1.2 将 demo_zuul 项目打成 app.jar

点击 idea 窗体左小角的 Terminal，然后将项目 demo_zuul 拖动到 Terminal 窗体里，接着输入 mvn clean package，回车，刷新 target 目录，即可在该目录下看到 app.jar。

6.13 防火墙开启 8888 端口（8888 端口为 demo_zuul 项目中自定义的 server.port 端口号）

如果没有开启 8888 端口，会出现通过网关代理去访问 article 服务时，出现访问错误情况。

#查看是否开启指定端口
$ sudo firewall-cmd --query-port=8888/tcp
no
#添加指定需要开放的端口
$ sudo firewall-cmd --add-port=8888/tcp --permanent
success
#移除指定端口
#firewall-cmd --permanent --remove-port=8888/tcp
#重新载入添加/移除的端口
$ sudo firewall-cmd --reload
#也可再查下是否开启指定端口
$ sudo firewall-cmd --query-port=8888/tcp
yes

6.1.4 docker 构建 zuul 镜像、创建和运行 zuul 容器、查看 zuul 容器运行日志

a. 构建镜像前的准备工作

$ sudo cd /usr/local/mydocker
# 将app.jar上传到该目录（/usr/local/mydocker/）
$ sudo ls
app.jar Dockerfile

因为在构建 eureka 镜像时，已经创建了一个用于存放 jar 包和 Dockerfile 的目录叫 mydocker，所以不用再创建。

另外，由于不管是哪个项目，都打包成了名为 app.jar，所以 Dockerfile 文件也可以复用。

故只需要把 demo_article 打成的 jar 包，上传到 /usr/local/mydocker 目录下，覆盖掉原先的 app.jar 即可。

b. 构建 zuul 镜像

# zuul为构建后的镜像名称，下面最后的.和.前面的空格一定不能少。最后的.表示使用当前目录中的Dockerfile来构建。
$ sudo docker build -t zuul .
Sending build context to Docker daemon  46.05MB
Step 1/3 : FROM jdk1.8
 ---> 1f2578d93bd0
Step 2/3 : ADD app.jar /app.jar
 ---> 9496a939de7f
Step 3/3 : ENTRYPOINT ["java","-jar","/app.jar"]
 ---> Running in e682a3f423e5
Removing intermediate container e682a3f423e5
 ---> 62c091b00c8f
Successfully built 62c091b00c8f
Successfully tagged eureka:latest
# 上面输出Successfully...表示构建article镜像成功,也可通过docker images命令查看是否构建成功
$ sudo docker images
REPOSITORY                TAG                 IMAGE ID            CREATED              SIZE
zuul                      latest              62c091b00c8f        About a minute ago   642MB
...
# 上面可以看到REPOSITORY下有一个名为zuul的镜像，即表示构建成功

c. 运行 zuul 容器

# docker run 表示创建一个新的容器并运行
# -d 表示以守护模式运行，也就是后台运行，非阻塞式运行
# --name=zuul 表示运行后的容器名称为zuul
# -p 8888:8888 表示将宿主机的9001端口和zuul容器的8888之间做个绑定
# 最后的zuul，是docker images中查看到的镜像名称
$ sudo docker run -d --name=zuul -p 8888:8888 zuul
94a28b1a9fdd2456aab3cbae3685e3fe77cd1754e2107a6f3bcc0b3d788051d1
#出现如上一个很长的字符串，表示运行docker创建了一个zuul容器，并运行zuul容器成功，但至于zuul容器中的zuul服务是否能和我们预期的那么部署成功，还待下一步验证

d. 验证 zuul 服务

首先查看 zuul 容器是否在运行中

#查看运行中的容器 (后面加 -a 可查看所有容器，不管该容器是否在运行中)

$ sudo # docker ps
CONTAINER ID        IMAGE                     COMMAND                  CREATED              STATUS              PORTS                    NAMES
94a28b1a9fdd        zuul                      "java -jar /app.jar"     About a minute ago   Up About a minute   0.0.0.0:8888->8888/tcp   zuul

可通过三种方式验证：

1. 通过浏览器访问 eureka 服务地址，查看 demo_zuul 服务是否注册到 eureka 上

2. 通过查看运行日志

# docker logs 查看docker容器运行日志
# -f --tail=30 一直查看最后30行的日志
# zuul容器的名称
$ sudo docker logs -f --tail=30 zuul

3. 通过 zuul 网关代理访问 demo_article 项目的 url

docker 微服务部署之：五、利用 DockerMaven 插件自动构建镜像

Docker 部署MySQL

1、创建配置目录

mkdir -p MySQL目录/conf

2、切换到配置目录

cd MySQL目录/conf

3、创建配置文件

vim my.cnf

[client]
# 设置mysql客户端连接服务端时默认使用的端口
port=3306
default-character-set=utf8mb4
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8mb4
[mysqld]
# 设置3306端口
port=3306
# 允许最大连接数
max_connections=1000
# 允许连接失败的次数。这是为了防止有人从该主机试图攻击数据库系统
max_connect_errors=100
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 是否对sql语句大小写敏感，1表示不敏感
lower_case_table_names=1
# MySQL连接闲置超过一定时间后(单位：秒)将会被强行关闭
interactive_timeout =1800
# MySQL默认的wait_timeout  值为8个小时, interactive_timeout参数需要同时配置才能生效
wait_timeout=1800
# Metadata Lock最大时长（秒）， 一般用于控制 alter操作的最大时长sine mysql5.6
# 执行 DML操作时除了增加innodb事务锁外还增加Metadata Lock，其他alter（DDL）session将阻塞
lock_wait_timeout=3600
# 内部内存临时表的最大值。
# 比如大数据量的group by ,order by时可能用到临时表，
# 超过了这个值将写入磁盘，系统IO压力增大
tmp_table_size=64M
max_heap_table_size=64M
# 设置分组模式
sql_mode=''STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION''
# 设置全局聚合方式
init_connect=''SET collation_connection = utf8mb4_general_ci''
init_connect=''SET NAMES utf8mb4''
# 设置密码验证规则
authentication_policy=mysql_native_password
# 服务端使用的字符集默认为UTF8
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
# 跳过客户端发送的字符集信息
skip-character-set-client-handshake
# 禁用DNS解析
skip-name-resolve

4、运行镜像

docker run -p 3306:3306 \
           --name=mysql \
           --restart=always \
           --privileged=true \
           -v MySQL目录/conf:/etc/mysql/conf.d \
           -v MySQL目录/logs:/var/log \
           -v MySQL目录/data:/var/lib/mysql \
           -v MySQL目录/mysql-files:/var/lib/mysql-files \
           -e MYSQL_ROOT_PASSWORD=数据库密码 \
           -d \
           mysql:8.0.32

--restart=always：随docker启动。
--privileged=true：容器内的root拥有真正的root权限。
-e MYSQL_ROOT_PASSWORD=：设置root账号的密码。

5、旧版本字符集校正

旧版本的字符集格式与8.0版本是有出入的，执行下面3个SQL的查询结果，即可校正MySQL字符集为8.0格式。

库

select concat(''alter database '', schema_name, '' default character set utf8mb4 collate utf8mb4_general_ci;'')
  from information_schema.schemata
 where schema_name not in (''sys'', ''mysql'', ''performance_schema'', ''information_schema'')
   and (lower(default_collation_name) != ''utf8mb4_general_ci'' or lower(default_character_set_name) != ''utf8mb4'');

表

select concat(''alter table '', table_schema, ''.'', table_name,
              '' default character set utf8mb4 collate = utf8mb4_general_ci;'')
  from information_schema.tables
 where table_schema not in (''sys'', ''mysql'', ''performance_schema'', ''information_schema'')
   and table_type = ''BASE TABLE''
   and lower(table_collation) != ''utf8mb4_general_ci'';

列

set group_concat_max_len = 10240;

select concat(c1, c2, '';'')
  from (select c1, group_concat(c2) c2
          from (select concat(''alter table '', t1.table_schema, ''.'', t1.table_name) c1,
                       concat('' modify '', ''`'', t1.column_name, ''` '', t1.data_type,
                              if(t1.data_type in (''varchar'', ''char''), concat(''('', t1.character_maximum_length, '')''),
                                 ''''),
                              if(t1.column_default != '''', concat('' default \'''', t1.column_default, ''\''''), ''''),
                              '' collate utf8mb4_general_ci'',
                              if(t1.is_nullable = ''NO'', '' not null'', '' null''), '' comment '', '''''''', t1.column_comment,
                              '''''''')                                                c2
                  from information_schema.columns t1,
                       information_schema.tables t2
                 where t1.table_schema = t2.table_schema
                   and t1.table_name = t2.table_name
                   and t2.table_type = ''BASE TABLE''
                   and (lower(t1.collation_name) != ''utf8mb4_general_ci'' or lower(t1.character_set_name) != ''utf8mb4'')
                   and t1.table_schema not in (''sys'', ''mysql'', ''performance_schema'', ''information_schema'')) t1
         group by c1) t;

关于docker 部署mysql详细过程(docker部署常见应用)和docker 部署 mysql的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于docker (部署常见应用)：docker 部署 redis、Docker 常见应用部署、docker 微服务部署之：四、安装 docker、docker 中安装 mysql 和 jdk1.8、手动构建镜像、部署项目、Docker 部署MySQL等相关内容，可以在本站寻找。

本文标签：