Docker的常用命令以及使用

发表于 分类于 阅读次数： 本文字数： 12k 阅读时长 ≈ 11 分钟 
1
2
3
4
5
6
作者: 夜泊1990
企鹅: 1611756908
Q 群: 948233848
邮箱: hd1611756908@163.com
博客: https://hs-an-yue.github.io/
B 站: https://space.bilibili.com/514155929/

第一章 Docker的基本操作命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
1. 查看Docker版本
	-> docker version
2. 搜索镜像(例如 搜索一个centos镜像)
	-> docker search centos
3. 拉取镜像(例如拉取centos镜像,将其下载到本地)
	-> docker pull centos
4. 列出当前Docker平台本地镜像
	-> docker images
	
	以下为本机展示的镜像列表
	REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
    centos        latest    300e315adb2f   4 weeks ago     209MB
    hello-world   latest    bf756fb1ae65   12 months ago   13.3kB
	
	--> REPOSITORY: 镜像仓库源
	--> TAG: 镜像的标签
	--> IMAGE ID: 镜像ID
	--> CREATED: 镜像创建时间
	--> SIZE: 镜像大小

5. 删除镜像
	-> docker rmi [镜像名称/镜像ID]
		--> 参数 -f 强制删除  docker rmi -f [镜像名称/镜像ID]
		--> 注意: 在删除镜像的时候最好先将容器(下面介绍)删除,否则可能删除失败
6. 运行镜像
	--> docker run [参数][镜像ID/镜像名称]
		--> 启动一个centos容器并且后台运行: docker run -itd --name="c01" centos /bin/bash
			--> -d 参数: 后台运行
			--> -i 参数: 以交互模式运行
			--> -t 参数: 为容器分配一个伪终端,常与-i参数一起搭配使用
			--> /bin/bash 参数: docker运行一个容器之后,必须保持这个容器里面的任意一个进程运行,否则容器就会在启动之后被杀死,/bin/bash就表示启动容器后启动bash
			--> -p 参数: 映射端口号,将容器内的应用的端口号映射到宿主机的端口号
			--> --name 参数: 自定义容器名称

7. 查看容器
	--> 查看当前正在运行的容器: docker ps 
		--> -a 参数: 查看当前所有的容器(已运行和未运行) docker ps -a
		
		CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
        b0faa3079666   centos    "/bin/bash"   16 minutes ago   Up 16 minutes             confident_cannon
        94eb3d8db458   centos    "/bin/bash"   17 minutes ago   Up 17 minutes             gallant_blackwell
        5db82b03c4e5   centos    "/bin/bash"   17 minutes ago   Up 17 minutes             festive_knuth
		
		--> CONTAINER ID:容器ID
		--> IMAGE: 镜像
		--> COMMAND: 启动容器时运行的命令
		--> CREATED: 容器的创建时间
		--> STATUS: 容器的运行状态
		--> PORTS: 容器运行映射的端口号
		--> NAMES: 容器的名称(如果不设置会自动分配)
	
8. 进入已运行的容(容器必须开启交互模式)
	--> 方式一: docker attach [容器ID]
	--> 方式二: docker exec -it [容器ID] /bin/bash
9. 从已经进入的容器中退出到宿主机
	--> 方式一 exit : 退出后容器被停止
	--> 方式二 Ctrl+d : 退出后容器被停止
	--> 方式三 Ctrl+p 和 Ctrl+q : 先按Ctrl+p在按Ctrl+q,退出后容器不会停止
10. 启动容器/停止/重启
	--> 启动容器: docker start [容器ID]
	--> 重启容器: docker restart [容器ID]
	--> 停止容器: docker stop [容器ID]
	--> 停止全部容器: docker stop $(docker ps -q)
11. 删除容器
	--> docker rm [容器ID/容器名称]  删除单个已经停止的容器
	--> docker rm $(docker ps -aq) 删除全部已停止的容器

第二章 Docker 运行命令的详细介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Docker运行(run)命令的详细介绍,使用tomcat镜像作为例子演示

1. 拉取tomcat镜像
	--> git pull tomcat
2. 运行tomcat(在运行之后首先将宿主机的防火墙关闭,或者是开启8080端口)
	--> docker run -p[主机端口号]:[容器端口号] -v [主机目录]:[容器目录] tomcat
	
		eg: docker run --name="tomcat001" -d -p 8080:8080 -v /home/hs/web:/usr/local/tomcat/webapps/ tomcat
			
			--name: 给运行的容器起一个名字
			-d    : 后台运行
			-p    : 将宿主机的端口号和容器的端口号想关联
			-v    : 挂载卷,将容器内的某一个目录挂载到宿主机的某一个目录上,可以实现容器和宿主机的数据共享
				-- v mydata:/data    冒号左侧是宿主机地址,冒号右侧是容器内地址
				
				上面的例子-v的意思就是将宿主机/home/hs/web目录的文件共享到容器内部的/usr/local/tomcat/webapps/目录下
				比如在/home/hs/web目录下放一个war包项目,就会共享到/usr/local/tomcat/webapps/目录下

第三章 Docker自定义构建镜像

第1节 自定义构建镜像的意义

1
2
3
4
1. 为什么要自己构建镜像文件
	-> 因为有的时候我们需要的镜像官方不一定有,或者我们需要的镜像功能比较多,官方提供的镜像功能不完善...
2. 怎么自定义一个镜像文件
	-> Docker提供了Dockerfile方式进行镜像的构建

第2节 Dockerfile 是什么

1
2
3
Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明

使用Dockerfile可以定制化构建属于自己的镜像文件

第3节 Dockerfile的使用

1
2
3
4
5
6
使用docker build命令通过Dockerfile构建镜像,构建可以通过本地路径(PATH)或者是网络路径(URL)构建,本地路径是一个本地文件系统,网络路径是一个GIT仓库地址

~$ docker build .  //传统方式
~$ docker build -f /path/to/a/Dockerfile . //采用-f参数指定构建哪一个Dockerfile文件
~$ docker build -t fqyb/myapp .   //构建完成之后指定一个仓库和标签 -t参数设置新镜像的仓库和标签
~$ docker build -t fqyb/myapp:1.0.0 -t fqyb/myapp:latest .  //如果构建完成之后添加到多个仓库可以添加多个-t参数

3.1 Dockerfile常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
RUN 命令

	语法: RUN <command> 或者 RUN ["executable", "param1", "param2"]

    执行一个shell脚本

    eg: RUN ["/bin/bash", "-c", "echo hello"]

ENV 命令
	语法: ENV <key> <value>

	就是指定一个环境变量，会被后续的RUN命令使用，并在容器运行时保持

     eg: 
     ENV MYSQL_VERSION 5.6
     RUN curl -SL "http://dev.mysql.com/get/Downloads/MySQL-$MYSQL_VERSION/mysql-$MYSQL_VERSION-linux-glibc2.5-x86_64.tar.gz" -o mysql.tar.gz

     可以使用$MYSQL_VERSION变量名获取后面的值5.6

COPY 命令
	语法: COPY <src> <dest>

	复制本地主机的<src>为容器的<dest>，目标路径不存在的时候，会自动创建

ADD 命令
	语法: ADD <src> <dest>

	复制指定的<src>到容器的<dest>，其中<src>可以是Dockerfile所在目录的一个相对路径（文件或目录）;也可以是一个URL;还可以是一个tar文件（自动解压为目录）

EXPOSE 命令
	语法: EXPOSE <port> [<port>...]

	这条命令告诉容器需要开放的端口号，以提供给互联系统使用，启动容器的时候需要通过-p或者-P来分配这些端口

    eg: EXPOSE 80 443 22 8080   
    eg: docker run -d -p 1022:22 -p 1080:80 -p 1443:443 nginx

USER 命令
    语法: USER daemon

	指定运行容器时候的用户名或者UID，后续RUN也会使用指定的用户

WORKDIR	命令
	语法: WORKDIR /path/to/workdir

    由于Dockerfile中不能使用cd命令，所以我们想要在哪个目录下操作的时候就需要切换进来。为后续的RUN，CMD以及ENTRYPOINT指定工作的目录
    可以使用多个WORKDIR命令，如果后面为相对路径，则是针对当前目录确定的

    WORKDIR /x
    WORKDIR y
    WORKDIR z
    最后进入的目录就是 /x/y/z   /x为根目录  y相对于x目录    z相对于y目录  所以最后就是/x/y/z    

CMD	命令  
    语法: 
        1. CMD ["executable", "param1", "param2"]使用exec执行，推荐方式。
        2. CMD command param1 param2在/bin/sh中执行，提供给需要交互的应用。
        3. CMD ["param1", "param2"]提供给ENTRYPOINT的默认参数。

        指定启动容器时执行的命令，每一个Dockerfile只能有一条CMD命令，如果有多条的话，只会执行最后一条。如果用户启动容器时指定了运行的命令，则CMD命令会被覆盖掉
    
ENTRYPOINT 命令
    语法: ENTRYPOINT ["executable", "param1", "param2"]或ENTRYPOINT command param1 param2（shell中执行）

    配置容器启动以后执行的命令，并且不能被docker run命令提供的参数覆盖。每一个Dockerfile只能有一个ENTRYPOINT命令，当存在多个的时候就只有最后一个会生效

VOLUME 命令
    语法: VOLUME ["/data"]

    Docker容器是基于镜像创建的,在容器运行的时候可能产生一些数据,比如说运行一个MYSQL的容器,这时候会在容器中写入很多数据,如果我们将容器删除,那么整个数据库里面的数据都会被删除.
    有没有一种方式可以将容器中产生的数据,保存到宿主机上,这样即便容器被删除,但是我们的数据还在.这个VOLUME属性就可以帮我们实现.
    在我们运行Docker容器时候使用 -v参数可以将VOLUME设置的参数映射到宿主机上
    
LABEL 命令
    语法: LABEL maintainer="SvenDowideit@home.org.au"  还可以设置作者 LABEL Author="张三"
    
    代替MAINTAINER属性,LABEL设置更灵活


注意: 以上命令根据Docker版本不同可能略有差异化,但是核心命令答题没有变化

3.2 Dockerfile命令使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1. 创建一个Dockerfile文件(文件名称叫做Dockerfile,没有后缀名)
2. 写一个简单的入门的Dockerfile文件
eg: 自定义一个内置tomcat的镜像(tomcat和基础镜像自己准备)

# 基础镜像
FROM centos

# 作者信息
LABEL Author="夜泊1990"

# 将tomcat文件复制到容器的指定位置
COPY ./tomcat  /usr/local/tomcat

# 将jdk文件复制到容器的指定位置
COPY ./jdk /usr/local/jdk

# 配置镜像内部JDK的环境变量
ENV JAVA_HOME /usr/local/jdk
ENV PATH $PATH:$JAVA_HOME/bin

# 指定镜像端口号
EXPOSE 8080

# 运行镜像时执行的命令
ENTRYPOINT /usr/local/tomcat/bin/startup.sh && tail -f /usr/local/tomcat/logs/catalina.out

3. docker build -t hs/tomcat:v1.0 .
4. 运行: docker run --name="app001" -d -p 8080:8080 -v /home/hs/web:/usr/local/tomcat/webapps/ hs/tomcat:v1.0
5. 访问: http://192.168.130.128:8080/demo/

第4节 Docker Compose

1
2
3
1. 官方地址: https://github.com/docker/compose

2. 注意: Compose只能在单主机上面进行多容器部署,不能在多主机进行容器部署,所以现在基本上都是用K8S进行操作,Compose在跨主机部署中使用较少

4.1 Compose 介绍

1
Compose 是一个可以定义和运行多个docker容器应用的工具,它使用一个YAML文件配置你的应用服务,并且使用一个命令就可以创建和启动配置里面的所有服务.

4.2 Compose 安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
1. 系统需求

    1.1 首先Linux系统上面要安装了Docker引擎
    1.2 运行Compose 最好是以一个非root用户运行

    创建Linux新用户,并且添加群组
    --> 创建群组 groupadd dockerCompose
    --> 创建用户并添加进群组 useradd dockerCompose -m -s /bin/false -d /home/dockerCompose -g dockerCompose

2. 安装步骤
	2.1 下载Compose
		sudo curl -L "https://github.com/docker/compose/releases/download/2.29.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
		
		如果下载失败,可以直接去github上手动下载,下载地址: https://github.com/docker/compose/releases
		例如下载此版本: https://github.com/docker/compose/releases/download/v2.29.1/docker-compose-linux-x86_64
		
	2.2 给Compose执行权限
		sudo chmod +x /usr/local/bin/docker-compose
		
	2.3 设置软连接
		sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

	2.4 查看Compose版本号
		docker-compose --version
		
3. 注意事项
	在下载Compose时，可能会因为网络原因造成下载失败,可以去github上面直接下载源文件然后上传到服务器的/usr/local/bin 目录下即可,如果下载的文件名字不叫docker-compose 可以使用mv命令重新命名为docker-compose

4.3 Compose 使用

4.3.1 使用Compose部署一个web服务器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1. 创建一个名为docker-compose.yml文件
2. 创建一个Dockerfile文件,docker-compose.yml基于Dockerfile运行(也可以不基于)
3. 准备Dockerfile文件和一个war包作为测试

	# 选择镜像
	from tomcat
	# 作者信息
    LABEL  "AUTHOR"="夜泊"
    # 将测试的web项目部署到tomcat的webapp目录下
    COPY ./web.war   /usr/local/tomcat/webapps

4. 准备docker-compose.yml文件

version: "2.0" # 版本,一般为2或者3版本
services:      # 服务器
    web:      # 服务器标记名称,名字自定义,为了区分services下的多个服务
    	build: .    # 构建当前根目录下的Dockerfile文件
    	container_name: 'app01'   # 给启动的容器起名字
    	ports:                    # 设置容器的宿主机的端口号映射,左侧为宿主机,右侧为容器
    		- 8081:8080
         
5. 在当前目录下敲击此命令启动服务: docker-compose up  如果后面带有 -d参数直接后台运行 docker-compose up -d
6. 宿主机浏览器访问 http://192.168.142.128:8081/web/
7. 查看容器的实时日志 docker logs -f 容器ID/容器名称
4.3.2 使用Compose部署两个web服务器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1. 创建一个名为docker-compose.yml文件
2. 创建一个Dockerfile文件,docker-compose.yml基于Dockerfile运行(也可以不基于)
3. 准备Dockerfile文件和一个war包作为测试

	# 选择镜像
	from tomcat
	# 作者信息
    LABEL  "AUTHOR"="夜泊"
    # 将测试的web项目部署到tomcat的webapp目录下
    COPY ./web.war   /usr/local/tomcat/webapps

4. 准备docker-compose.yml文件

version: "2.0" # 版本,一般为2或者3版本
services:      # 服务器
    web1:      # 服务器标记名称,名字自定义,为了区分services下的多个服务
    	build: .    # 构建当前根目录下的Dockerfile文件
    	container_name: 'app01'   # 给启动的容器起名字
    	ports:                    # 设置容器的宿主机的端口号映射,左侧为宿主机,右侧为容器
    		- 8081:8080
    web2:      # 服务器标记名称,名字自定义,为了区分services下的多个服务
    	build: .    # 构建当前根目录下的Dockerfile文件
    	container_name: 'app02'   # 给启动的容器起名字
    	ports:                    # 设置容器的宿主机的端口号映射,左侧为宿主机,右侧为容器
    		- 8082:8080
         
5. 在当前目录下敲击此命令启动服务: docker-compose up  如果后面带有 -d参数直接后台运行 docker-compose up -d
6. 宿主机浏览器访问 
	-> http://192.168.142.128:8081/web/
	-> http://192.168.142.128:8082/web/
4.3.3 使用Compose部署两个web服务器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
相比于3.3.2 
3.3.2 缺点: 
	1. web1服务build构建Dockerfile生成一个新镜像,并且运行起来
	2. web2服务也build构建Dockerfile生成另一个镜像,并且运行起来,缺点就是构建同一个Dockerfile,生成同一个镜像,毫无意义
3.3.3 对3.3.2的docker-compose.yml进行了修改

version: "3.9"
services:
    web1:
        build: .
        image: "web:1.0"    # build构建Dockerfile时,生成镜像的镜像仓库名称和TAG版本
        container_name: 'app01'  # 给启动的容器起名字
        ports:
            - 8081:8080          # 端口号映射,冒号左侧是宿主机,冒号右侧是容器
    web2:
        image: "web:1.0"    # 第二个服务使用第一个镜像,不在重新构建
        container_name: 'app02'
        ports:
            - 8082:8080

第四章 常用的Docker镜像介绍和使用

第1节 MYSQL安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1. 搜索mysql镜像,选择需要的镜像名字
	docker search mysql
	
2. 从云端拉取镜像
	docker pull mysql
	
3. 运行MYSQL镜像(参考第二章)
	
	docker run --name=mysql -it -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d 镜像ID
	
	eg:docker run --name=mysql -it -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d 7ce93a845a8a
	
4. 设置和访问
	4.1 设置MYSQL访问权限,任务IP地址都可以访问
		需要设置MYSQL中 mysql库中的user表中的root用户的host值,修改成 % 
		
		第一步: 进入到正在运行的容器中(命令在上面第一章)
			docker exec -it [容器ID] /bin/bash     容器ID通过 docker ps 获取
			eg: docker exec -it 3127c8e72215 /bin/bash 
		
		第二步: 使用mysql命令登陆MYSQL服务器
			mysql -uroot -p 访问MYSQL服务器
			
		第三步: 修改mysql库中user表的root账户的host列的值
			3.1 查询MYSQL服务器的所有库命令  show databases;
			3.2 切换mysql库命令  use mysql;
			3.3 查询用户名为root的用户信息命令  select user,host FROM user where user="root";
			3.4 如果查询出来的root用户的host的值有一个为%,那么就不需要在更新,如果root的host值不是%然后通过下面命令更新
			3.5 更新用户root的host列的值,将其更新成% 命令为 update user set host="%" WHERE user="root"; 
			
	4.2 使用navcat或者其他MYSQL客户端连接
		通过 Linux命令 ifconfig 查看主机IP地址,然后通过navcat连接MYSQL

注意: 
	1. MYSQL需要宿主机开放3306端口号,否则防火墙会屏蔽,不允许外部机器访问,所以需要关闭防火墙,或者配置3306可以穿透防火墙
	2. 如果用的是云服务器,例如阿里云,那么可以手动配置3306端口号暴漏给用户,具体配置方式,查找阿里云配置手册

第2节 Redis安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1. 搜索redis镜像,选择需要的镜像名字
	docker search redis
	
2. 从云端拉取镜像
	docker pull redis

3. 运行MYSQL镜像
	docker run --name redis -p 6379:6379  -d [镜像ID] --requirepass "123456" --appendonly yes
	eg: docker run --name redis -p 6379:6379  -d 509b2fc82da6 --requirepass "123456" --appendonly yes
	
4. 参数简单介绍:
	--requirepass 设置密码可以不加,不给redis数据库设置密码
	--appendonly  aof持久化,默认不开启,此参数可以不加,设置yes开启持久化
	-d 参数要放在 --requirepass和--appendonly之前,否则可能报错
	
注意: 
	1. Redis需要宿主机开放6379端口号,否则防火墙会屏蔽,不允许外部机器访问,所以需要关闭防火墙,或者配置6379可以穿透防火墙
	2. 如果用的是云服务器,例如阿里云,那么可以手动配置6379端口号暴漏给用户,具体配置方式,查找阿里云配置手册

第3节 RabbitMQ安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1. 搜索RabbitMQ镜像,选择需要的镜像名字(搜索带web页面的镜像)
	docker search rabbitmq:management
	
2. 从云端拉取镜像
	docker pull rabbitmq:management
	
3. 运行RabbitMQ镜像
	docker run –name rabbitmq -d -p 15672:15672 -p 5672:5672 rabbitmq:management

4. 查看容器运行日志
	docker logs -f 容器ID        容器ID通过 docker ps  获取
	eg: docker logs -f 5507c9379a8e
	
	从打印的日志中可以发现这几句日志信息
    Creating user ‘guest’ // 默认创建了用户名 guest
    Setting user tags for user ‘guest’ to [administrator] // 添加了administrator角色
    Setting permissions for ‘guest’ in ‘/‘ to ‘.‘, ‘.‘, ‘.*’ // 密码为 guest
    
5. 访问web页面
	通过 Linux命令 ifconfig 查看主机IP地址
	在浏览器中输入:   http://192.168.233.128:15672

注意: 
	1. RabbitMQ需要宿主机开放15672和5672端口号,否则防火墙会屏蔽,不允许外部机器访问,所以需要关闭防火墙,或者配置15672和5672可以穿透防火墙
	2. 如果用的是云服务器,例如阿里云,那么可以手动配置15672和5672端口号暴漏给用户,具体配置方式,查找阿里云配置手册

第4节 Docker控制面板安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1. 搜索portainer镜像,选择需要的镜像名字
	docker search portainer/portainer
	
2. 从云端拉取镜像
	docker pull portainer/portainer
	
3. 运行portainer镜像
	docker run -d -p 9000:9000 --name portainer --restart always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer

4. web页面访问 控制面板
	通过 Linux命令 ifconfig 查看主机IP地址
	在浏览器中输入:   http://192.168.233.128:9000/
	第一次访问,需要设置密码,设置完就可以访问了

页面展示如下:
--------------------------已经到底啦！--------------------------