docker入门教程_docker教程

文章目录

• 1. Docker概述
• • 1.1. 为什么使用Docker？
  • 1.2.Docker和虚拟机的区别
  • 1.3.Docker能干什么？
  • • 应用更快速的交付和部署。
    • 更便捷的升级和扩缩容
    • 更简单的系统运维
    • 更高效的计算资源利用
• 2. Docker的安装
• • 2.1 名词概念
  • 2.2 安装Docker
  • • 1.卸载旧版本
    • 2.需要的安装包
    • 3.设置镜像仓库
    • 4. 更新yum
    • 5. 安装docker相关
    • 6. 启动
    • 7.测试
    • 8. 查看下载的helloworld镜像
    • 9. 卸载docker
  • 2.3 阿里云镜像加速
• 3. Docker常用命令
• • 3.1帮助命令
  • 3.2镜像命令
  • • docker images 查看所有本地的主机上的镜像
    • docker search 搜索镜像
    • docker publl 下载镜像
    • 删除镜像
  • 3.3容器 命令
  • • 新建容器并启动
    • 退出容器
    • 查看当前运行的容器
    • 删除容器
    • 启动和停止容器
  • 3.4常用其他命令
  • • 后台启动容器
    • 查看日志
    • 查看容器中进程信息
    • 查看镜像元数据
    • 进入当前正在运行的容器
    • 从容器内拷贝文件到主机上
  • 3.5实操
  • • 部署nginx
  • 3.6 Portainer可视化面板安装(平常不会使用，测着玩)
• 4.Docker镜像讲解
• • 4.1镜像是什么
  • 4.2 Docker镜像加载原理
  • 4.3 分层理解
  • 4.4 commit镜像
• 5.容器数据卷
• • 5.1 什么是容器数据卷
  • 5.2 使用数据卷
  • 5.3 实战：安装mysql
  • 5.4 具名和匿名挂载
  • 5.5 初识DockerFile
  • 5.6 数据卷容器
• 6.DockerFile
• • 6.1 DockerFile构建过程
  • • 基础知识：
  • 6.2 DockerFile的指令
  • 6.3 实战测试一 自建centos镜像
  • 6.4 实战测试二 自建tomcat镜像
  • 6.5 发布自己的镜像
  • • 发布到DockerHub
    • 发布到阿里云
  • 6.6 小结
• 7. Docker网络
• • 7.1 理解Docker0
  • 7.2 --link（不推荐）
  • 7.3 自定义网络
  • • 网络模式
    • 测试
  • 7.4 网络连通
  • 7.5 部署redis集群
• 8. springboot微服务打包Docker镜像

1. Docker概述

1.1. 为什么使用Docker？

开发以及上线的过程中，环境配置是十分麻烦的，每一台机器都要部署环境，非常费时费力，那么能不能在发布项目的时候带上环境安装打包呢？（jar+redis+mysql+jdk+es…）。

在服务器配置应用的环境时，非常的麻烦，并且不能够跨平台。

对于这些问题，Docker给出了解决方案。

java–>jar(环境)–>打包项目带上环境（镜像）–>docker仓库—>下载镜像—>直接运行。

1.2.Docker和虚拟机的区别

• 虚拟机： 在window中装一个vmware，通过这个软件可以虚拟出一台或多台电脑，大小超长几个G，启动需要几分钟。
• docker：隔离，镜像十分的小巧，大小可能几个M,KB，秒级启动。
• 传统虚拟机，虚拟出一个完整 的操作系统，然后在这个系统中安装和运行软件。
• 容器内的应用直接运行在宿主机的内容，容器没有自己的内核，也没有虚拟我们的硬件，所以非常轻便
• 每个容器间相互隔离，每个容器内都一个属于自己的文件系统，互不影响

1.3.Docker能干什么？

DevOps(开发，运维)

应用更快速的交付和部署。

传统运维：一堆文档，安装程序；

Docker：打包镜像发布测试，一键运行。

更便捷的升级和扩缩容

使用Docker，部署应用和搭积木一样。

更简单的系统运维

在容器化之后，我们的开发、测试环境都是高度一致的

更高效的计算资源利用

Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例。服务器的性能可以压榨到极致。

2. Docker的安装

2.1 名词概念

Docker的基本组成

镜像（image）：

docker镜像就好比一个模板，可以通过这个模板来创建容器服务，tomcat镜像===》run===》tomcat1容器（）提供服务器，通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。

容器（container）：

Docker利用容器技术，独立运行一个或一个组应用，通过镜像来创建；

启动、停止、删除，基本命令；

目前就可以把这个容器理解为就是一个简易的linux系统

仓库（repository）：

就是存放镜像的地方；仓库分为公有和私有；

Docker Hub（默认是国外的）

阿里云。。。都有容器服务器（配置镜像加速）

2.2 安装Docker

1.卸载旧版本

$ sudo yum remove docker 
              docker-client 
              docker-client-latest 
              docker-common 
              docker-latest 
              docker-latest-logrotate 
              docker-logrotate 
              docker-engine
1
2
3
4
5
6
7
8

2.需要的安装包

yum install -y yum-utils
1

3.设置镜像仓库

yum-config-manager 
--add-repo 
https://download.docker.com/linux/centos/docker-ce.repo #默认国外
    
yum-config-manager 
--add-repo 
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #阿里云
1
2
3
4
5
6
7

4. 更新yum

yum makecache fast
1

5. 安装docker相关

docker-ce 社区 docker-ee 企业版

yum install docker-ce docker-ce-cli containerd.io
1

6. 启动

systemctl start docker
1

7.测试

#查看版本
docker version
docker run hello-world
1
2
3

8. 查看下载的helloworld镜像

docker images
1

9. 卸载docker

#卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#删除资源
rm -rf /var/lib/docker #docker默认工作路径
1
2
3
4

2.3 阿里云镜像加速

阿里云—>容器镜像服务—>镜像加速器

sudo mkdir -p /etc/docker
#此地址每个人不同，内网地址，其他人无法使用
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://f63lm5vo.mirror.aliyuncs.com"]  
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker
1
2
3
4
5
6
7
8
9
10
11

3. Docker常用命令

全部命令图示

3.1帮助命令

service docker start #开启服务 
docker version #显示版本信息
docker info #显示系统信息
docker 命令 --help #万能命令
1
2
3
4

3.2镜像命令

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

[root@localhost ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        11 months ago       13.3kB

#解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的ID
CREATED 镜像创建时间
SIZE 镜像的大小
#可选项
Options:
  -a, --all             列出所有镜像
  -q, --quiet           只显示镜像的ID
1
2
3
4
5
6
7
8
9
10
11
12
13
14

docker search 搜索镜像

docker publl 下载镜像

docker pull 镜像名:tag  #tag 版本号
1

删除镜像

docker rmi -f id #删除指定id的镜像
docker rmi -f $(docker images -aq)  #删除全部
docker rmi -f id id id #删除多个
1
2
3

3.3容器 命令

说明：有了镜像才能创建容器

测试centos；

docker pull centos
1

新建容器并启动

docker run 可选参数 image
#参数说明
--name “name” 容器名字 tomcat01 tomcat02 ，用来区分容器
-d			后台方式运行
-it	容器名 地址路径		使用交互方式运行，进入容器查看内容 （例:docker run -it centos /bin/bash）
-p			指定容器的端口	-p 8080：8080
	-p	ip:主机端口：容器端口
	-p	主机端口：容器端口（常用）
	-p	容器端口
-P			随机指定端口
1
2
3
4
5
6
7
8
9
10

退出容器

# 停止容器并退出
exit
# 容器不停止退出
`ctrl`+P+Q
1
2
3
4

查看当前运行的容器

#查看当前运行的容器
docker ps
#查看当前运行的容器+历史运行过的容器
docker ps -a
#显示最近运行的容器
-n=? 
#显示容器的编号
-q
1
2
3
4
5
6
7
8

删除容器

docker rm 容器id #删除指定容器，不能删除正在运行的容器，强制删除 rm -f
docker rm -f $(docker ps -aq)  #删除全部
docker ps -a -q|xargs docker rm #管道方式删除全部
1
2
3

启动和停止容器

docker start 容器id	#启动容器
docker restart 容器id #重启容器
docker stop 容器id	#停止当前运行的容器
docker kill 容器id	#强制停止当前容器
1
2
3
4

3.4常用其他命令

后台启动容器

#命令 docker run -d 镜像名
docker run -d centos
#问题docker ps ，发现 centos停止了

#常见的坑：docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
1
2
3
4
5

查看日志

docker logs -f -t --tail 条数 容器id
1

查看容器中进程信息

docker top 容器id
1

查看镜像元数据

docker inspect 容器id
1

进入当前正在运行的容器

我们通常容器都是使用后台方式运行，需要进入容器，修改一些配置

#第一种命令 进入容器后开启一个新的终端，可以在里面操作（常用）
docker exec -it 容器id bashshell （例：docker exec -it 0a360e8a37c1 /bin/bash）
#第二种命令 进入容器正在执行的终端，不会启动新的进程
docker attach 容器id
1
2
3
4

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

docker cp 容器id：容器内路径 主机路径

#拷贝是一个手动过程，可以使用 -v 卷的技术，实现自动同步
1
2
3

3.5实操

部署nginx

#1. 搜索镜像  
#2. 下载镜像
#3. 运行测试
docker run -d --name nginx01 -p 3344:80 nginx
# 请求服务测试是否启动
curl localhost:3344
1
2
3
4
5
6

访问成功

3.6 Portainer可视化面板安装(平常不会使用，测着玩)

安装运行

docker run -d -p 8000:9000 
1

–restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试

4.Docker镜像讲解

4.1镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

所有应用，直接打包dockers镜像，就可以直接跑起来。

如何得到镜像：

• 从远程仓库下载
• 朋友拷贝
• 自己制作镜像 DockerFile

4.2 Docker镜像加载原理

4.3 分层理解

4.4 commit镜像

docker commit #提交容器成为一个新的镜像
#命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名：【TAG】
1
2
3

实战测试

#1.启动一个默认的tomcat
#2.发现这个默认的tomcat没有webapps应用，是因为官方的镜像默认webapps下没有文件
#3.自己将webapps.site下的基本文件拷到webapps下
#4.以后就想用这个镜像，将这个镜像通过commit提交为一个镜像，以后就可以使用修改过的镜像；想发布给别人，在下文dockerFile时讲
docker commit -a="pavel" -m="add webapps app" 容器id tomcat02:1.0
1
2
3
4
5

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

就好比VM的快照。

5.容器数据卷

5.1 什么是容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像！

如果数据都在容器中，那么我们容器删除，数据就会丢失。需求：数据可以持久化

MYSQL，容器删了，删库跑路！需求：mysql数据可以保存到本地

容器直接可以有一个数据共享的技术。

这就是卷技术。目录的挂载，将我们容器内的目录，挂载到linux上。

容器的持久化和同步操作；容器间也可以数据共享

5.2 使用数据卷

方式一：直接使用命令来挂载 -v

docker run -it -v -p 主机目录:容器内目录 
#测试
docker run -it -v -p /home/test:/home centos /bin/bash
#启动起来之后可以通过 docker inspect 容器id 通过元数据来查看是否挂载
1
2
3
4

5.3 实战：安装mysql

# 1.下载镜像
# 2.运行容器，需要挂载数据;安装启动MySQL需要配置密码，需要注意！
# -e 环境配置
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7.30
1
2
3
4

5.4 具名和匿名挂载

匿名挂载，在 -v 只写了容器内的路径，没有写容器外的

# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx
# 查看卷 
docker volume --help
# 查看所有volume的情况
docker volume ls


#具名挂载(容器内路径最前不加/就只是卷名 不是容器外路径)
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
#查看卷路径
docker volume inspect juming-nginx
1
2
3
4
5
6
7
8
9
10
11
12
13

所有容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxx；

通过具名挂载可以方便的找到我们的卷，大多数情况使用这种挂载。

5.5 初识DockerFile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本!

通过这个脚本可以生成一个镜像，

方式二：通过Dockerfile挂载卷

docker inspect 容器id

这种方式的使用非常多，因为我们通常会构建自己的镜像

5.6 数据卷容器

容器和容器之间同步

例：两个Mysql同步数据

# 通过--volumes-from 关联容器，相当于子容器继承了父容器
1

多个mysql实现数据共享

结论：

容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。

但是一旦持久化到了本地，这个时候，本地的数据是不会删除的。

6.DockerFile

docker是用来构建镜像的文件！命令参数脚本。

构建步骤：

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

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

6.1 DockerFile构建过程

基础知识：

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

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单；

Docker镜像逐渐成为企业交付的标准，必须要掌握！

DockerFile: 构建文件，定义了一切的步骤，相当于源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供服务器

6.2 DockerFile的指令

FROM # 基础镜像，一起从这里开始构建 centos
MAINTAINER # 镜像是谁写的，姓名+邮箱
RUN # 镜像构建的时候需要运行的命令
ADD # 步骤： 比如tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR # 镜像的工作目录
VOLUME #挂载的目录
EXPOST #保留端口配置
CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD # 当构建一个被继承DockerFile的时候，就会运行ONBUILD指令。触发指令。
COPY # 类似ADD，将我们文件拷贝到镜像中
ENV # 构建的时候设置环境变量
1
2
3
4
5
6
7
8
9
10
11
12

6.3 实战测试一 自建centos镜像

构建自己的centos镜像

DockerHub中99%镜像都是从这个基础镜像过来的 FROM scrath，然后配置需要的软件和配置来进行构建

创建自己的centos

1. 编写DockerFile文件，添加Hub镜像上没有的命令

   FROM centos

   作者

   MAINTAINER pavelmiaohanyu@126.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 dockersfile文件路径 -t 镜像名：版本号 .

3. 测试运行

   docker run -it 镜像名：版号

4. 列出本地镜像的变更历史

   docker history 镜像id

拿到镜像时，可以通过这个命令研究一下这个镜像怎么做的。

6.4 实战测试二 自建tomcat镜像

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

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

   FROM centos
   MAINTAINER pavelmiaohanyu@126.com

   将文件拷贝进容器内

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

   添加tomcat和jdk的压缩包

   ADD jdk-8u161-linux-x64.tar.gz /usr/local/
   ADD apache-tomcat-8.5.55.tar.gz /usr/local/

   安装需要的命令

   RUN yum -y install vim
   RUN yum -y install net-tools
   #配置环境变量
   ENV MYPATH /usr/local
   #根目录
   WORKDIR $MYPATH

   ENV JAVA_HOME /usr/local/jdk1.8.0_161
   ENV CLASSPATH %JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
   ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.55
   ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.55
   ENV PATH $PATH:$JAVA_HOME/bin:$CATALIN{A}_{H}OME/lib:$CATALINA_HOME/bin
   #暴露端口
   EXPOSE 8080
   #启动时要运行的命令
   CMD /usr/local/apache-tomcat-8.5.55/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.55/bin/logs/catalina.out

3. 构建镜像

   docker build -t mytomcat .

4. 启动镜像

   docker run -d -p 9090:8080 --name mytomcat -v /home/pavel/docker-build/tomcat/webapps/xj:/usr/local/apache-tomcat-8.5.55/webapps/xj -v /home/pavel/docker-build/tomcat/tomcatlogs:/usr/local/apache-tomcat-8.5.55/logs mytomcat

5. 访问测试

6. 发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布）

6.5 发布自己的镜像

发布到DockerHub

1提交自己的镜像

#登录
docker login -help
#给上传的镜像命名
docker tag 镜像名 docker用户名/自定义镜像名：自定义版本号
#push
docker push 自定义镜像名
1
2
3
4
5
6

退出登录

docker logout
1

发布到阿里云

打开容器镜像服务

1. 创建命名空间

2. 创建镜像仓库

3. 浏览仓库

6.6 小结

7. Docker网络

7.1 理解Docker0

测试

结论：tomcat01和tomcat02是公用的一个路由器，docker0.

所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP

小结

Docker使用的是linux的桥接，宿主机是一个Docker容器的网桥 docker0;

veth-pair

7.2 --link（不推荐）

其实这个tomcat03就是在本地配置了tomcat02的配置

本质探究：–link 就是我们在hosts配置中增加了一个配置

下载Docker已经不建议使用–link；

推荐自定义网络；

docker0问题：不支持容器名连接访问。

7.3 自定义网络

查看所有的docker网络

网络模式

bridge：桥接 （docker默认）

none：不配置网络

host：和宿主机共享网络

container：容器内网络联通（用的少，局限很大）

测试

# 我们直接启动的命令 默认有--net bridge，而这个就是我们的docker0
docker run -d -P --name tomcat01 --net bridge tomcat
#docker0特点：默认，域名不能访问，--link可以打通连接！

#我们可以自定义网络
[root@localhost bin]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
096a037158422ba28fa832c3b7a488dcff6e941d002b5d5f5350b237b100c32b
[root@localhost bin]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
d8a759735ff1        bridge              bridge              local
03c0d84e10ba        host                host                local
096a03715842        mynet               bridge              local
f076b6c9c5a7        none                null                local

#查询自定义网络的属性
docker network inspect mynet

#用自己的网络启动容器
docker run -d -P --name tomcat-net-01 --net mynet tomcat
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

为什么要用自定义网络 ？

容器间可以通过容器名ping通。

好处：

redis -不同的集群使用不同的网络，保证集群是安全和健康的

mysql -不同的集群使用不同的网络，保证集群是安全和健康的

7.4 网络连通

打通不同网络间的容器

# 测试打通 tomcat01 -mynet
docker network connect 网络名 容器名
docker network connect mynet tomcat01 
# 联通之后就是将tomcat01放到了 mynet 网络下；

# 一个容器两个ip地址
# 阿里云服务： 公网ip 私网ip 就是这么实现的
1
2
3
4
5
6
7

7.5 部署redis集群

#创建网卡
docker network create redis --subnet 172.38.0.0/16

# 通过shell脚本来创建6个redis配置
for port in $(seq 1 6); 
1
2
3
4
5

do
mkdir -p /mydata/redis/node-$port/conftouch/mydata/redis/node-${port}/conf/redis.conf
cat << EOF >>/mydata/redis/node-$port/conf/redis.confport6379bind0.0.0.0cluster-enabledyescluster-config-filenodes.confcluster-node-timeout5000cluster-announce-ip172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

#启动容器 (依次启动6个）
docker run -p 6371:6379 -p 16371:16379 --name redis-1 
1
2

-v /mydata/redis/node-1/data:/data
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#进入redis
docker exec -it redis-1 /bin/sh (redis下没有bash）

#创建集群
redis-cli --cluster create ip:端口（1-6） --cluster-replicas 1
1
2
3
4
5

8. springboot微服务打包Docker镜像

1. 构建springboot项目
2. 打包应用
3. 编写dockerfile
4. 构建镜像
5. 发布运行

[外链图片转存中…(img-iHET0Vrl-1608604680892)]