Docker学习笔记

1.前言

docker为什么会出现？
环境配置十分麻烦，每一个机器都需要配置环境
发布一个项目jar需要配置（MySQL、redis、jdk、…），项目不能都带上环境安装打包

传统：开发jar，运维来做
现在：开发打包部署上线，一套流程做完

Docker针对以上问题，提出了解决方案

docker可以做什么？
比较docker和虚拟机技术的不同：

• 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装运行软件
• 容器内应用直接运行在 宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，更轻便
• 每个容器间相互隔离，每个容器都有一个属于自己的文件系统，互不影响

DevOps：开发 运维
应用更快速的交付和部署

• 传统：安装程序
• docker：打包镜像发布测试，一键运行

更便捷的升级和扩缩容
项目打包为一个镜像，扩展 服务器A 服务器B
更简单的系统运维
在容器化后，我们的开发、测试环境都是高度一致
更高效的资源利用
docker是内核级的虚拟化，可以在一个物理机上运行很多的容器实例（多套运行环境），充分利用服务器的资源

2.docker安装

2.1 docker 基本组成

镜像（image）：模板（类），通过一个镜像可以创建多个容器
容器（container）：独立运行一个或一组应用，通过镜像创建
仓库（repository）：存放镜像的地方，分为公有仓库和私有仓库

2.2 docker安装

1.查看环境

2.卸载旧版本

yum remove docker \
          docker-client \
          docker-client-latest \
          docker-common \
          docker-latest \
          docker-latest-logrotate \
          docker-logrotate \
          docker-engine

3.安装所需的软件包

yum install -y yum-utils 

4.设置镜像仓库（阿里云）

yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

5.安装docker相关的内容

# 更新yum软件包索引
yum makecache fast

# 安装docker docker-ce 社区
yum install docker-ce docker-ce-cli containerd.io

6.启动docker

systemctl start docker

7.使用docker version查看是否安装成功

8.启动hello-world镜像：docker run hello-world

9.卸载docker

# 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io

# 删除资源
rm -rf /var/lib/docker

# /var/lib/docker docker的默认工作路径

2.3 底层原理

docker是一个client-server 结构的系统，容器内部相当于一个小的Linux，相互隔离
新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导

3.docker常用命令

3.1 帮助命令

docker version	#显示docker的版本信息
docker info	#显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help #帮助命令

3.2 镜像命令

docker images #查看所有本地的主机上的镜像

docker search xxx #搜索镜像

docker pull xxx #下载镜像

docker rmi xxx #删除镜像

3.3 容器命令

说明：有了镜像才可以创建容器，Linux，下载一个centos镜像进行测试

docker pull centos

新建容器并启动

docker run [可选参数] image
#参数说明
--name="Name" 容器名字，用来区分容器
-d 	后台方式运行
-it	 使用交互方式运行，进入容器查看内容
-p	 指定容器的端口 -p 8080:8080
	-p 主机端口：容器端口

-P 	随机指定端口

#测试，启动并进入容器
[root@iZ8vbisqeqec8qgypcxvyqZ /]# docker run -it centos /bin/bash
[root@dbb48fe6c0c6 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

#从容器中退回主机
exit #直接容器停止并退出
Ctrl+P+Q #容器不停止退出

列出所有的运行的容器

docker ps 命令 #列出当前正在运行的容器
-a # 列出当前正在运行的容器+历史运行过的容器
-n=? #显示最近创建的容器
-q #只显示容器的编号

删除容器

docker rm 容器id	#删除指定的容器，不能删除正在运行的容器
docker rm -f $(docker ps -aq)	#删除所有的容器

启动和停止容器操作

docker start 容器id	#启动容器
docker restart 容器id	#重启容器
docker stop 容器id	#停止当前正在运行的容器
docker kill 容器id	#强制停止当前容器

3.4 常用的其他命令

后台启动容器

#命令 docker run -d 镜像名

查看日志

docker logs -f -t --tail 容器id

查看容器中的进程信息

top 命令
docker top 容器id

查看镜像元数据

docker inspect 容器id

进入当前正在运行的容器

#方式一
docker exec -it 容器id  /bin/bash

#方式二
docker attach 容器id 
正在执行当前代码...

从容器内拷贝文件到主机上

docker cp 容器id：容器内文件路径 容器外文件路径

查看docker内存消耗资源

docker stats

4.docker部署

4.1 部署nginx

#1.搜索镜像
docker search nginx
#2.下载镜像
docker pull nginx
#3.查看镜像
docker images

#4.通过镜像启动容器，运行测试
docker run -d --name="nginx01" -p 3344:80 nginx
或者
docker run -d --name nginx01 -p 3344:80 nginx

#5.进入容器
docker exec -it nginx01 /bin/bash

端口暴露

！！！每次修改nginx配置文件，都需要进入容器内部，如果我们可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改，-v 数据卷

4.2 部署tomcat

#官方使用
docker run -it --rm tomcat:9.0
#之前没有--rm参数启动容器，停止容器后也可以查到容器 但--rm使用后会删除容器，并没有记录

#下载再启动
docker pull tomcat:9.0

docker run -d --name tomcat01 -p 8888:8080 tomcat:9.0

#进入容器
docker exec -it tomcat01 /bin/bash

[root@iZ8vbisqeqec8qgypcxvyqZ ~]# docker exec -it tomcat01 /bin/bash
root@ed26bb59c621:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf     lib   native-jni-lib  webapps
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      include  logs  temp	     work

4.3 部署elasticsearch

#由于ES耗用内存消耗过大，我们启动容器时需要限制内存使用大小-e配置环境
docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" -e "discovery.type=single-node" elasticsearch:7.6.2

#查看内存占用大小
docker stats

CONTAINER ID   NAME              CPU %     MEM USAGE / LIMIT     MEM %     NET I/O         BLOCK I/O      PIDS
be50b6afe0a7   elasticsearch01   0.40%     364.2MiB / 1.715GiB   20.74%    656B / 0B       16MB / 729kB   43
ed26bb59c621   tomcat01          0.08%     104.3MiB / 1.715GiB   5.94%     8.71kB / 73kB   18.7MB / 0B    41
71b323027fe8   amazing_cannon    0.00%     536KiB / 1.715GiB     0.03%     806B / 0B       0B / 0B        1

使用kibana连接es

5.可视化

portainer：docker图形化界面管理工具

# 启动镜像

docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock 
-v /dockerData/portainer:/data --restart=always --name portainer portainer/portainer:latest

#- v: 目录映射，将/var/run/docker.sock映射到容器中，用于访问Docker的守护进程，控制Docker。
	/dockerData/portainer保存Portainer的配置信息。
#–restart=always: 代表在容器退出时总是重启容器，还有其他几种重启策略：no、on-failure、on-failuer:n、unless-stopped

访问测试：http://39.103.195.183:9000/

用户名：admin 密码：admin123

6.docker镜像原理

6.1 镜像

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、库、环境变量和配置文件
所有的应用，直接打包docker镜像就可以直接跑起来
如何获取镜像？
你可以创建自己的镜像，也可以只使用其他人创建并在Docker Hub中发布的镜像。要构建自己的镜像，需要创建一个Dockerfile，使用简单的语法定义创建和运行镜像所需的步骤。Dockerfile中的每一条指令都会在图像中创建一个层。当你更改Dockerfile并重新构建镜像时，只有那些已经更改的层才会重新构建。与其他虚拟化技术相比，这是镜像如此轻量级、小巧和快速的原因之一。

• 从Docker Hub上拉取镜像(常用)
• 自己制作镜像 Dockerfile 创建
• 从别人那边拷贝一份

6.2 分层

所有docker镜像都起始于一个检查镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层

6.3 commit 镜像

docker commit #提交容器成为一个新的副本
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名：[TAG(版本)]

实战测试

#启动一个默认的tomcat
docker exec -it tomcat01 /bin/bash

#如果这个默认的tomcat没有webapps应用，需要将webapps.dist下的文件拷贝到webapps里面
cp -r webapps.dist/* webapps/

#将我们操作过的容器通过commit提交为一个镜像，以后我们使用该镜像
docker commit -a="zhengxin" -m="add webapps app" ed26bb59c621 my_tomcat:1.0

如果想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像

7.容器数据卷

目录挂载，将我们容器内的目录挂载到Linux上面

容器的持久化和同步操作，容器间也是可以实现数据共享的
使用数据卷：

方式一：直接使用命令挂载	-v
docker run -it -v 主机目录：容器内目录 

docker run -it -v /home/test_docker:/home centos /bin/bash

查看镜像元数据：docker inspect 容器id


以后我们修改只需要在本地修改即可，容器内会自动同步
实战MySQL：
思考MySQL数据持久化的问题

#获取镜像
docker pull mysql:5.7

#运行容器，需要做数据挂载，安装MySQL需要配置密码
docker run -d -p 3310:3306 -v /home/test_docker/mysql/conf:/etc/mysql/conf.d 
-v /home/test_docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=admin123 
--name my_mysql mysql:5.7.25

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

#启动成功，本地使用navicat连接测试

具名和匿名挂载：

#匿名挂载：容器外没有命名挂载目录地址
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx

#查看所有volume的情况
docker volume ls


#具名挂载：通过 -v 卷名：容器内路径
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

#查看这个卷

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/_data
我们通过具名挂载可以方便的找到我们的一个卷，大部分情况使用具名挂载
如何确定时具名挂载还是匿名挂载：

-v 容器内路径	#匿名挂载
-v 卷名：容器内路径	#具名挂载
-v /宿主机路径：：容器内路径	#指定路径挂载

扩展：

#通过 -v 容器内路径：ro rw 改写读写权限
ro	readonly	#只读
rw	readwrite #可读可写

#一旦这个设置了容器权限，容器对我们挂载出来的内容就有了限定
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

#ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内时无法操作

初始dockerfile:
dockerfile用来构建docker镜像的构建文件，命令脚本，通过这个脚本可以生成镜像，镜像是一层一层的，每个命令都是一层的

#1.创建一个dockerfile文件
#文件中的内容 指令（大写） 参数
FROM centos

VOLUME ["volume01","volume02"]

CMD echo "---end---"

CMD /bin/bash

#这里的每个命令都是镜像的一层

运行我们自己写的容器

这个卷和外部一定有一个同步目录

查看卷挂载路径

假设构建镜像时没有挂载卷，需要手动镜像挂载 -v 卷名：容器内路径

数据卷容器：
多个MySQL同步数据：



通过 --volumes-from 可以实现容器间共享
删除docker01，docker02和docker03仍然可以访问这个文件

结论：容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止，但是一旦持久化到了本地，这种情况，本地的数据不会删除

8.DockerFile

dockerfile 是用来构建docker镜像的文件，命令参数脚本
构建步骤：

1. 编写一个dockerfile 文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（DockerHub，阿里云镜像）

很多官方的镜像都是最基础的，很多功能都没有，我们通常需要自己搭建自己的镜像

8.1 DockerFile 构建过程

基础知识：

1. 每一个保留关键字（指令）都必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件
Docker 镜像逐渐成为了企业交互的标准
步骤：开发-部署-运维…

• DockerFile：构建文件，定义了一切的步骤，源代码
• DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品 [类似于原来的jar war]
• Docker容器：容器就是镜像运行起来提供服务

8.2 DockerFile 指令

FROM		#基础镜像，一切从这里开始构建
MAINTAINER		#镜像由谁写的，姓名+邮箱
RUN		#镜像构建的时候运行的命令
ADD		#步骤，如tomcat镜像，这个tomcat压缩包，添加内容
WORKDIR		#镜像工作目录
VOLUME		#挂载的目录
EXPOSE		#暴露端口
CMD		#指定容器启动时要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT		#指定容器启动时要运行的命令，可追加命令
ONBUILD		#当构建一个被继承 dockerfile 这时候会运行该命令，触发指令
COPY		#类似ADD，将我们文件拷贝到镜像中
ENV		#构建的时候设置环境变量

实战测试：
Docker Hub中99% 镜像都是从这个基础镜像过来的 FROM scatch，然后配置需要的软件和配置来进行构建

创建一个自己的centos

#1.编写dockerfile文件
[root@iZ8vbisqeqec8qgypcxvyqZ test_docker]# vim dockerfile-centos
[root@iZ8vbisqeqec8qgypcxvyqZ test_docker]# cat dockerfile-centos
FROM centos:7
MAINTAINER zhengxin<123.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash

#2.通过这个文件构建镜像
#命令 docker build -f dockerfile文件路径 -t 镜像名:[tag] .

#3.测试运行

查看镜像的历史安装步骤，如何生成的

制作Tomcat镜像

1. 准备镜像文件 tomcat 压缩包，jdk 压缩包

2. 编写dockerfile 文件，官方命名 Dockerfile，build会自动寻找这个文件，就不需要 -f 指定了

FROM centos:7

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u351-linux-x64.tar.gz /usr/local
ADD apache-tomcat-8.5.87.tar.gz /usr/local

RUN yum -y install vim

ENV MYPATH /usr/local

WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_351
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.87
ENV CATALINA_BATH /usr/local/apache-tomcat-8.5.87

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 9090

CMD /usr/local/apache-tomcat-8.5.87/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.87/bin/logs/catalina.out

3. 构建镜像

docker build -t diytomcat .

4. 启动镜像

docker run -d -p 9090:8080 --name zhengxintomcat -v /home/test_docker/build/tomcat/test:/usr/local/apache-tomcat-8.5.87/webapps/test 
-v /home/test_docker/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-8.5.87/logs diytomcat

5. 访问测试
6. 发布项目：由于做了卷挂载，我们直接在本地编写项目就可以发布，web.xml/index.jsp

8.3 发布镜像

DockerHub

1. 地址：https://hub.docker.com/
2. 登录账号
3. 在我们服务器上提交自己的镜像

4. 登录完成就可以提交镜像了，docker push zhengxin/diycomcat:1.0

阿里云镜像服务

1. 登录阿里云
2. 找到容器镜像服务
3. 创建命名空间
4. 创建容器镜像
5. 浏览阿里云镜像信息
6. …