docker快速入门_docker 容器写代码(1)

那我们现在就开始实操：
访问 MySQL 镜像库地址：https://hub.docker.com/_/mysql?tab=tags 。
可以通过 Sort by 查看其他版本的 MySQL，默认是最新版本 mysql:latest 。

我们这里下载mysql5.7的docker pull mysql:5.7,下载成功和可以看到。

然后就是关键了，我们要创建容器同时进行端口映射

docker run -d -p 3306:3306 --privileged=true -v /opt/mysql/conf/my.cnf:/etc/my.cnf -v /opt/mysql/data:/var/lib/mysql -v /opt/mysql/logs:/logs -e MYSQL\_ROOT\_PASSWORD=your password --name mysql mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci

我们来解释一下，首先我们通过宿主机的3306端口映射容器的3306端口。
然后通过数据卷将mysql的data数据文件,conf配置文件分别挂载到宿主机自己创建的三个目录，将来我们就可以直接同步数据，非常的方便。
最后需要在防火墙开放我们宿主机的3306端口！
那么下面我们就进入容器验收成果：
我们通过mysql -uroot -p输入密码登入我们的mysql

然后在mysql客户端试试能否远程登录,连接前要保证容器是开启的状态，没有记得docker start xxx

连接成功，docker安装mysql成功.

4.2、docker安装tomcat

这个比较复杂，我们需要用到一些新知识。
首先还是之前的老两步：
search–pull
我这里pull的是和我本地一致的版本：tomcat:8.5.63-jdk8-openjdk
pull好后，我们就需要创建容器，学过javaweb知识的肯定知道tomcat有两个比较重要的文件夹，webapps以及conf这两个文件夹，为了方便，我们自然而然能想到通过挂载的方式解决。
我们通过以下命令：

docker run -d --name tomcat -p 8080:8080 -v /opt/tomcat/conf:/usr/local/tomcat/conf -v /opt/tomcat/webapps:/usr/local/tomcat/webapps -v /opt/tomcat/logs/:/usr/local/tomcat/logs  --restart=always  tomcat:8.5.63-jdk8-openjdk

直接创建后，发现启动不起来，一直是restart状态，将 --restart=always 去掉重新run后发现状态变成了exit，就是启动不起来。
这是因为上面的命令中，我们也挂载了conf文件夹。这个是tomcat的配置文件夹。必须把tomcat中的conf中的文件复制到挂载文件上（即/home/supervision_app/app/conf目录下需要有配置文件）
而我们将空的数据卷与我们的容器同步，结果全是空的，自然启动不起来了。
所以我们暂时有一个思路，**创建一个不挂载数据卷的tomcat容器,如果能正常启动起来，就将它这里的数据移动到我们原来的数据卷中。**其实这个思路是可行的。
我们docker rm -f tomcat后再次通过

docker run -d --name tomcat -p 8080:8080 --restart=always  tomcat:8.5.63-jdk8-openjdk

然后防火墙开放8080端口。
创建tomcat，现在通过docker ps -a发现状态变成正常的了，那么我们通过
docker exec -it tomcat /bin/bash进入容器，进入成功。

这个时候exit退出后，由于我们做了端口映射，我们试试远程能不能访问：
一输入发现404

这里其实已经说明，我们的tomcat已经起了。端口什么的都配好了。
使用命令: docker exec -it 运行的tomcat容器ID /bin/bash 进入到tomcat的目录
进入webapps文件夹,发现里面是空的(tomcat默认的欢迎页面实际上放在的路径应该是:webapps/ROOT/index.jsp或者index.html)
发现下边还有个webapps.dist的文件,进入才发现原本应该在webapps文件中的文件都在webapps.dist文件中

那么很简单，我们将webapps给删了，然后将webapps.dist改为webapps就行了。

rmdir webapps
mv webapps.dist/ webapps

exit后docker restart tomcat后就可以发现启动成功

但其实，我们解决的并不完美，因为再另启动一个Tomcat容器时又会回到之前的窘境，既实际上问题的根源是在生成容器的镜像上，只有将镜像修改了，再生成的容器才不会再出现这个问题。

所以我们得通过将我们的容器映射为新的镜像，然后通过这个镜像创建容器，就无后患了。
我们可以使用docker commit命令将运行着的容器映射成新的镜像
格式：docker commit -a='作者-这个随意写' -m='‘修改内容--随意写' 容器名称或者ID 新生成镜像的名称:自己定义的版本号
比方我以我现在这个可以正常运行的tomcat容器映射成镜像，

docker commit -a='孟博文' -m='修改404' tomcat  tomcat:v1

我们映射完后通过docker images可以看到我们的镜像生成成功了。

此时还没完，我们现在肯定想的是用这个新镜像创建新容器，但是我们之前那个tomcat容器还没有利用完：
因为你想想，我这个时候创建新容器，挂载还是空的，照样不行，所以我们将之前正常的tomcat容器文件复制到我们的挂载的数据卷上。
那怎么移动呢，docker自己提供了cp命令。

docker cp 容器名or id:容器目录or 文件 数据卷目录

我们将我们的conf以及webapps目录拷贝到/opt/tomcat下，在移动之前将以前空的文件删掉就行。

docker cp tomcat:/usr/local/tomcat/conf/ /opt/tomcat/
docker cp tomcat:/usr/local/tomcat/webapps/ /opt/tomcat/

然后发现我们的数据卷此时就有数据了：

这个时候tomcat容器光荣退休，我们把它删了。

docker rm -f tomcat

然后用我们的新镜像创建新的容器并挂载我们数据卷

docker run -d --name tomcat -p 8080:8080 -v /opt/tomcat/conf:/usr/local/tomcat/conf -v /opt/tomcat/webapps:/usr/local/tomcat/webapps -v /opt/tomcat/logs/:/usr/local/tomcat/logs  --restart=always  tomcat:v1

如果发现status为up就代表成功！去浏览器输入发现同样能进入主页！

4.3、docker部署nginx

如果tomcat安装成功，其实nginx就非常简单了。
首先我们pull nginx的镜像，我这里拉取的是1.19.0的

然后通过docker run创建一个正常的nginx的容器

docker run -d --name=nginx -p 80:80 --restart=always nginx:1.19.0

创建成功后，我们可以直接访问192,168.200.130:80访问

但是我们现在还没挂载，借用之前安装tomcat的思路，我们同样先在/opt创建nginx文件夹，然后在这下面创建三个文件夹：conf,logs,html分别存放我们的配置文件，日志文件，以及项目。
而nginx的这三份对应的文件在：
1、日志位置：/var/log/nginx/
2、配置文件位置：/etc/nginx/nginx.conf
3、项目位置：/usr/share/nginx/html
我们通过cp命令拷贝到我们的数据卷即可：

docker cp /var/log/nginx/ /opt/nginx/logs
docker cp nginx:/usr/share/nginx/html /opt/nginx/
docker cp nginx:/etc/nginx/nginx.conf /opt/nginx/conf

‘
这个时候通过docker rm -f nginx
然后创建新容器并挂载数据卷

docker run -d --name=nginx --restart=always -p 80:80 -v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /opt/nginx/html/:/usr/share/nginx/html -v /opt/nginx/logs:/var/logs/nginx nginx:1.19.0

此时通过docker ps -a

这个时候访问192.168.200.130:80即可访问到我们的nginx,docker安装nginx成功！

4.4、docker安装redis5

拉取镜像redis:5:docker pull redis:5

然后创建/opt/redis/conf和/opt/redis/data两个目录

然后去https://download.redis.io/redis-stable/redis.conf下载redis.conf文件传到/opt/redis/conf

vim这个文件，需要注意修改的地方：
bind 127.0.0.1 #注释掉这部分，这是限制redis只能本地访问
protected-mode no #默认yes，开启保护模式，限制为本地访问
daemonize no#默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程，改为yes会使配置文件方式启动redis失败
databases 16 #数据库个数（可选），我修改了这个只是查看是否生效。。
dir ./ #输入本地redis数据库存放文件夹（可选）
appendonly yes #redis持久化（可选）
修改完后，就可以创建容器并挂载了

docker run --restart=always -d --privileged=true -p 6379:6379 -v /opt/redis/conf/redis.conf:/redis.conf -v /opt/redis/data:/data --name redis redis:5 redis-server --appendonly yes

这里介绍一些参数的意义：
--privileged=true 提升容器内权限
redis-server redis-server就是redis的启动命令
--appendonly yes 开启数据持久化

然后在redis客户端发现一样能登陆成功，redis安装成功！

五、dockerfile

提前剧透：dockerfile就是用来制作镜像的
思考一下：
Docker 镜像本质是什么？
Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个个G？
Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？

在讲原理之前，大家不妨先了解一下操作系统和linux的文件系统。
操作系统组成部分：
1.进程调度子系统
2.进程通信子系统
3.内存管理子系统
4.设备管理子系统
5.文件管理子系统
6.网络通信子系统
7.作业控制子系统
Linux文件系统由bootfs和rootfs两部分组成
 bootfs：包含bootloader（引导加载程序）和 kernel（内核）
 rootfs： root文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin，/etc等标准目录和文件
不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等

5.1、docker镜像原理

Docker镜像是由特殊的文件系统叠加而成
最底端是 bootfs，并使用宿主机的bootfs，比方linux操作的时候会加载一次内核，然后docker加载的时候就不会再次重复加载，而是直接使用之前linux加载的内核。所以docker启动非常快。实现一种复用效果。
第二层是 root文件系统rootfs,称为base image
然后再往上可以叠加其他的镜像文件，比方我们可以在基础镜像上放上jdk镜像，然后在jdk镜像上接着放tomcat的镜像。这三部分组合起来，我们就把它称作tomcat镜像。这种组合性的镜像叫做只读镜像！那么这样的好处，仙子啊假设我在tomcat这样一个组合镜像基础上，再安装一个nginx的镜像，只读镜像已经有的，如果nginx也刚好需要，它就不需要再去下载了，即我下载的每一层镜像都可以被复用！
统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统。 这也就解释了为什么tomcat这样一个镜像就有500多Mb,centos镜像反而只要200Mb.
一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像成为基础镜像。
只读镜像不能修改，如果我想修改的话，就有了下面的方法，当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器。

而我们可以通过容器创建新的镜像，由此对镜像去做出一些改变，而可读镜像仍然是固定的，可复用的！

那么我们现在就来回答一下刚才的思考题：
1.Docker 镜像本质是什么？
是一个分层文件系统
2.Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个个G？
Centos的iso镜像文件包含bootfs和rootfs，而docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层
3.Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？
由于docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小500多MB
我们可以通过docker inspect tomcat:v1看一下我们的tomcat到底被分为多少层：你可以看到被分成了特别多层：

5.2、容器转化为镜像

命令：docker commit -a’xxxx作者信息’ -m’修改信息’ 容器id/容器名称 自定义镜像名称:自定义版本号
比方我们将修改好的tomcat转化为镜像：

docker commit -a='孟博文' -m='修改404' tomcat  tomcat:v1

这样就生成了我们想要的镜像，这在今后是非常方便的，我们比方在tomcat部署了一个web项目，然后我们就可以将它转化为我们的镜像，然后将这个镜像通过某种方式转给其他人，就ok了。
那我们该怎么将镜像分享出去呢，docker有一个压缩命令可以将镜像压缩为文件。

docker save -o 压缩文件名称（可以加路径，不加默认当前目录） 镜像名称:版本号

我们可以将这个压缩文件发给其他人，然后其他人可以把这个压缩文件转化为镜像，然后使用就是我们自己写改好的东西了。
那怎么把压缩文件还原成镜像：

docker load -i 压缩文件名称

那我们现在从头到尾演示一遍：
为了一个需要注意的知识点，我现在新建一个test文件夹然后写一个页面放进我们的webapps叫做test.html!

然后由于挂载，它肯定是放在了我们的容器中的，我们可以看一下演示一下：

现在我将这个生成镜像叫做tomcat:v2

docker commit -a '孟博文' -m '挂载页面' tomcat tomcat:v2

然后我们先进去创建一个v2的容器看看我们挂载的test.html还在不在，假设我创建的tomcat容器我不挂载任何一个目录，因为你发给别人，别人肯定不能挂载到你这里的文件。

docker run -d --name=tomcat2 -p 8888:8080 --restart=always tomcat:v2

运行后进去这个容器，发现我们的test文件夹不见了！访问肯定也是404

docker commit是只会保留容器的数据，不会保留任何挂载在宿主机的数据。
如果我们在我们刚才生成的镜像里创建文件，那么毫无疑问会被保留下来，这也是为什么我们将空的webapps删了，将webapps.dist改为webapps能够在新镜像保留下来的原因。那怎么保留我们的数据，我们在之后的dockerfile会讲解。
然后我们现在尝试着将我们这个镜像生成压缩文件，然后删除我们这个v2镜像，再把这个压缩文件还原，看是否能重新生成该镜像。

docker save -o /opt/tomcat/tomcat.tar tomcat:v2

docker load -i /opt/tomcat/tomcat.tar 

镜像重新生成成功，演示完毕！

5.3、dockerfile概述以及相关关键字

dockerfile概念：
Dockerfile 是一个文本文件
1、包含了一条条的指令
2、每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
3、对于开发人员：可以为开发团队提供一个完全一致的开发环境
4、对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了
5、对于运维人员：在部署时，可以实现应用的无缝移植

我们可以在docker官网搜到一些dockerFile.
Dochub网址：https://hub.docker.com

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于那个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
CMD	容器启动命令	提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build的时候复制文件到image中
ADD	添加文件	build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV	环境变量	指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG	构建参数	只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME	定义外部可以挂载的数据卷	指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
EXPOSE	暴露端口	定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER	指定执行用户	指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD	触发器	当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL	发送信号量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

5.4、dockerfile案例—自定义centos

我们自定义一个centos镜像要实现以下功能：
1、默认登陆路径为/usr
2、可以使用vim
实现步骤：
定义父镜像：FROM centos:7
定义作者信息：MAINTAINER mbw <mbw@mbw.com>
执行安装vim命令： RUN yum install -y vim
定义默认的工作目录：WORKDIR /usr
定义容器启动执行的命令：CMD /bin/bash
通过dockerfile构建镜像：docker bulid –f dockerfile文件路径 –t 镜像名称:版本 URL
我们现在在/opt创建dockerfile/centos目录，在其下vim一个dockerfile文件，写上以下内容：

然后通过docker build -f /opt/docker-files/centos/dockerfile -t mycentos:v1 .
-f后接的是dockerfile的路径
-t是自定义的镜像名:版本号
.表示当前路径，一般都是这个
生成后，我们通过docker images 查看

然后通过docker run -it --name=mycentos mycentos:v1创建并进入我们的容器
发现我们的默认工作目录已经变成了/usr

然后试下vim，发现也可以成功。那么自定义centos就算完成了。

5.5、dockerfile实例二:测试一个springboot的项目

我们创建一个非常简单的springboot的项目来测试是否能运行

在保证项目没问题的前提下，我们通过mvn package将我们的项目打成jar包

我们可以通过java -jar xxx.jar正常运行

然后来到docker这边
首先pull一个jdk8的镜像

docker pull abrtech/alpine-oraclejdk8

一切都成功的情况下，我们可以创建dockerfile。
在/opt/docker-files创建project/docker_springboot目录，将生成的jar包放入并创建dockerfile

Dockerfile内容如下：
FROM 基础镜像:FROM abrtech/alpine-oraclejdk8
ADD 类似于linux命令中的copy:
ADD docker_springboot-0.0.1-SNAPSHOT.jar app.jar
暴露项目的服务端口：EXPOSE 8080
启动命令：CMD java -jar app.jar
编写完后cd 到/opt/docker-files/project/docker_springboot执行
docker build -f ./Dockerfile -t app .创建镜像
执行完后可以通过docker images看到我们生成的镜像：

然后运行容器启动jar包

docker run -it -p 9090:8080 --name=springboot_docker app

发现项目成功运行起来，输入192.168.200.130:9090/hello，访问成功！

六、docker compose

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。
例如要从Dockerfile build image 或者去dockerhub拉取image
要创建多个container
要管理这些container（启动停止删除）
这样的工作量是非常恐怖且浪费时间的！
服务编排：按照一定的业务规则批量管理容器

6.1、服务编排

Docker Compose概念
Docker Compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：
1、利用 Dockerfile 定义运行环境镜像
2、使用 docker-compose.yml 定义组成应用的各服务
3、运行 docker-compose up 启动应用

安装docker Compose

curl -L "https://get.daocloud.io/docker/compose/releases/download/1.27.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

然后设置文件可执行权限

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

验证是否安装成功可通过docker-compose -v,显示版本号就说明docker-compoe安装成功！

要是想删除其实docker-compose也很简单，因为我们是通过二进制包方式安装的，直接删除这个文件就好

rm /usr/local/bin/docker-compose

6.2、docker-compose编排nginx+springboot的项目

我们首先通过docker images查看
我们的镜像

之前我们直接通过run我们的app容器启动我们的springboot项目，但是假设现在我们需要nginx反向代理我们的项目，你可能会想，我再启动我的nginx就好了，是可以这样，但万一你的项目又要很多种数据库，再加上消息队列，还需要布置集群，你还愿意一个一个启动吗？
所以我们通过docker compose将这些全部放一起：
我们在/opt下新建docker-compose/docker-compose.yml,这个yml名字不能改变。
然后编辑docker-compose.yml，语法格式注意是yml

version: '3'
services:
  #第一个要编排的服务
 nginx:
#基础镜像
     image: nginx:1.19.0
#端口映射
     ports:
       - 9090:80
 #链接到其它服务的中的容器，这里可以是别名也可以是服务名称
     links:
       - app
   #数据卷挂载，挂载我们宿主机自己nginx的配置文件
     volumes:
       - ./nginx/conf.d:/etc/nginx/conf.d
#第二个服务，其次也是被nginx链接的服务app
   app:
     image: app
#暴露的端口号
     expose:
       - "8080"

然后就是nginx的配置文件
我们在docker-compose.yml处于的当前目录新建当时我们挂载的目录
mkdir -p /nginx/conf.d,然后在这下面创建mbw.conf这个配置文件

这样我们写的配置文件自然会被挂载进去，配置文件内容如下：

server {
      listen 80;
      access_log off;


      location / {
          proxy_pass http://app:8080;
      }
}

意思就是当访问192.168.200.130,就会自动代理到app这个镜像的8080端口。
这个app其实是我们刚才links里链接的app镜像。
然后:wq保存退出，cd …/…/返回装有yml的目录
通过docker-compose up启动我们的docker-compose即可

启动成功！我们访问192.168.200.130:9090/hello(9090是映射的nginx的80端口)

七、docker私有仓库

我们maven也有自己的仓库，为了加载速度能够更快。
docker也可以搭建自己的私有仓库。
Docker官方的Docker hub（https://hub.docker.com）是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像 到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜 像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。
一般来说，我们搭建的私有仓库的服务器肯定和当前使用的服务器是分开的，但是为了方便，我们就直接在当前服务器搭建。

7.1、私有仓库搭建

1、拉取私有仓库镜像

docker pull registry

2、启动私有仓库容器

docker run -id --name=registry -p 5000:5000 registry

3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{“repositories”:[]} 表示私有仓库 搭建成功

4、修改daemon.json

vim /etc/docker/daemon.json 

在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip