Docker01 - docker快速入门

Docker快速入门

docker 使用的是 go 语言进行开发的

• 官网: https://www.docker.com；
• 文档地址：https://docs.docker.com；
• 仓库地址：https://hub.docker.com

一：Docker概述

1：虚拟机技术和容器化技术

docker就是将程序和其需要的环境封装到了一起

虚拟机技术和Docker的不同

• 传统的虚拟机技术，模拟出一个硬件，然后在上面安装一套完整的操作系统，然后在这个操作系统上运行和安装软件
• 容器内的软件直接运行在宿主机上的内容，没有内核，也没有虚拟硬件

docker中每一个容器之间互相隔离，都有自己的文件系统，互相不影响

2：Docker名词解释

2.1：Docker镜像(images)

• 好比是一个模板，可以通过这个模板来创建容器服务
• tomcat的镜像 -> docker run -> tomcat1容器实例
• 通过这个镜像可以创建多个实例，好比可以通过一个 java class 可以new多个这个类的实例一样

2.2：Docker容器(containers)

• 容器技术独立运行一个或者一组应用， 通过镜像进行创建
• 启动，停止，删除基本命令
• 容器可以简单的理解为一个小型的linux系统

2.3：Docker仓库(registry)

• 仓库就是存放镜像的地方
• 分为共有仓库和私有仓库
• 最大的docker镜像仓库 -> Docker hub(默认是国外的，可以配置镜像进行加速)

3：Docker下载安装

3.1：安装

1. 安装底层工具

# 这里我们安装docker的底层工具，会自动提示我们下载，很快就会完成了
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

2. 加入阿里云yum仓库提速docker的下载过程

# 增加阿里云的docker下载仓库，默认情况下，Docker的官方是从国外的服务器上下载的，下载速度是非常慢的，甚至失败
# 所以在这里我们是使用yum-config-manager组件来指定一个新的下载资源，指向的是阿里云的应用服务器，以此提高下载速度
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3. 更新一下仓库的源信息

sudo yum makecache fast # centos stream 9这个镜像没有fast参数，可以不要这个

4. 安装docker客户端和docker引擎

sudo yum -y install docker-ce

5. 启动和版本查看

# 启动docker
sudo service docker start

# 查看版本验证docker是否安装成功
docker version

6. Aliyun镜像加速

https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

至此，docker安装部分结束

3.2：卸载

1：移除安装的软件

yum remove docker-ce docker-ce-cli containerd.io

2：移除相关文件夹

sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

3.3：ali云加速

注册一个属于自己的阿里云账户(可复用淘宝账号) -> 获得加速器地址连接 -> 登陆阿里云开发者平台 -> 进入控制台 -> 产品和服务 -> 弹性计算 -> 容器镜像服务

二：Docker基本命令

1：帮助命令

文档：https://docs.docker.com/engine/reference/commandline/docker/

systemctl start docker # 启动docker 
systemctl stop docker # 停止docker
systemctl restart docker # 重启docker
systemctl enable docker # 开机启动docker
systemctl status docker # 查看docker状态

docker info # 查看docker概要信息
docker --help # 查看docker总体帮助文档
docker 具体命令 --help # 查看docker命令帮助文档

2：镜像相关命令

2.1：docker images

列出所有的本地的镜像

docker images [OPTIONS] [REPOSITORY[:TAG]]

• REPOSITORY -> 表示镜像的仓库源；
• TAG -> 镜像的标签版本号；
• IMAGE ID -> 镜像ID；
• CREATED -> 镜像创建时间；
• SIZE -> 镜像大小

同一仓库源可以有多个 TAG版本，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。

如果你不指定一个镜像的版本标签，将默认使用最新版本 -> tag = lastest

2.2：docker search

搜索指定的镜像

docker search [OPTIONS] TERM

2.3：docker pull

下载(拉取)镜像

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

2.4：docker rmi

删除指定的镜像

docker rmi [OPTIONS] IMAGE [IMAGE...]

docker rmi -f [image_id] # 可以通过指定image id进行删除
docker rmi [name: tag] # 可以通过指定name : tag进行删除
docker rmi -f $(docker images -aq) # 删除全部的镜像

2.5：镜像提交

对自己的镜像进行提交操作

docker commit  # 提交容器成为一个新的版本

# -m -> message -> 可以忽略
# -a -> author -> 可以忽略
docker commit -m[信息] -a[作者] [容器id] target_image_name[tag]

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

3：容器相关命令

有了镜像才能创建容器，（就是有了类才能创建实例）

3.1：docker run【重中之重】

新建一个容器并启动

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

# 下面列出几个常用的[OPTIONS]参数
--name = "Name"  # 容器的名字，用来进行容器的区分
-d  # 后台方式进行运行
-e # 指定环境变量
-v # 挂载到宿主机指定的目录（宿主机目录：容器目录）
-it  # 通过交互的方式进行运行
-P  # 随机指定端口
-p  # 指定容器的端口，有下面四种使用方式
# 方式一 -> -p ip:主机端口:容器端口
# 方式二 -> -p 主机端口:容器端口 [最常用]
# 方式三 -> -p 容器端口
# 方式四 -> 容器端口

从容器中退出到服务器

exit() 退出后停止

ctrl + p + q 退出后不停止依然运行

🎉 创建容器有两种方式：

3.2：docker ps

列出当前正在运行的容器

docker ps [OPTIONS]

3.3：docker rm

删除容器

docker rm [OPTIONS] CONTAINER [CONTAINER...]

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

# 列出所有的容器编号后重定向作为docker rm的参数进行删除，和docker rm $(docker ps -aq)同理
docker ps -a -q | xargs docker rm  # 删除所有的容器

3.4：docker exec

进入正在运行的容器的命令

docker exec -it container_id /bin/bash

exec和attach的区别

当多个窗口同是attach到同一个容器的时候，所有窗口都会同步显示；当某个窗口因命令阻塞时，其他窗口也无法执行操作

• 使用 docker exec -it 容器id /bin/bash 进入容器并开启一个新的bash终端。 退出容器终端时，不会导致容器的停止

• 使用 docker attach 容器id 进入正在执行容器，不会启动新的终端， 退出容器时，会导致容器的停止。

3.5：启动和停止容器

docker start [OPTIONS] CONTAINER [CONTAINER...]  # 启动容器
docker restart [OPTIONS] CONTAINER [CONTAINER...] # 重启容器
docker stop [OPTIONS] CONTAINER [CONTAINER...] # 停止容器
docker kill [OPTIONS] CONTAINER [CONTAINER...] # 杀掉容器

3.6：其他常用命令

3.6.1：docker logs

查看日志

docker logs -tf --tail [number] container_id
-tf  # 显示日志
--tail [number]  # 要显示的条数

3.6.2：docker top

查看容器中的进程

docker top container_id

3.6.3：docker inspect

查看镜像的元数据

docker inspect container_id

3.6.4：docker cp

在容器和本地文件系统之间复制文件/文件夹

docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH

4：总结

4.1：核心命令图

4.2：docker是怎么工作的

docker是C/S的系统结构，守护线程运行在主机上，通过Socket从客户端访问

server接收到client的指令，就会开始执行

三：基本安装部署演示

1：Nginx测试

# 1：搜索docker镜像
docker search nginx

# 2：拉取最新nginx镜像
docker pull nginx

# 3：查看当前的所有的镜像，方便检查nginx是不是已下载成功
docker images

# =====> 下面是容器操作 <=====
# 4：启动镜像，创建容器
docker run 
	-d # 后台运行
	--name nginx01 # 容器命名 
	-p 3344:80  # 端口映射 3344是宿主机端口，映射容器的80端口
	nginx # 使用的镜像名称

# 5：查看当前的容器
docker ps

内部映射图

# 以后台的方式进入到容器中
docker exec -it nginx01 /bin/bash

# 查看nginx01的相关的信息
whereis nginx
cd /etc/nginx

2：Tomcat测试

2.1：镜像拉取和容器启动

# 搜索docker镜像
docker search tomcat
# 拉取最新镜像
docker pull tomcat
# 查看当前的所有的镜像，方便检查tomcat是不是已下载成功
docker images

# 启动镜像，创建容器
# 起一个别名，通过公网端口号3355，访问内部的808端口(映射性)
docker run 
	-d 
	--name tomcat01 # 指定容器名称
	-p 3355:8080 # 端口映射 3355是宿主机端口，映射容器的8080端口
	tomcat # 指定使用的镜像

# 查看当前的容器
docker ps
# 进入容器
docker exec -it tomcat01 /bin/bash

2.2：阉割tomcat的处理

如果使用的是阿里云镜像加速，将会得到一个阉割版的Tomcat，很多内容都不支持

• linux的命令少了，像什么ll都不支持
• webapps中没有内容

如果发生这个问题可以将webapps.dist文件夹下的所有的内容都拷贝到webapps中

# 将webapps下的dist中的所有的内容拷贝给webapps
cp -r webapps/dist/* webapps

# 查看容器状态，可以看到还是123456
docker ps

# 进行提交
docker commit 
	-a='author01' # auth
	-m='add webapps' # message
	123456 # 容器id
	tomcat01:1.0 

# 查看镜像，可以发现此时有tomcat01了
docker images

四：镜像的仓库发布和获取

1：本地镜像发布到docker hub(了解即可)

中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流

docker login # 登录docker

# 进行给镜像命名
docker tag 
	java-demo:v1.0
	cuihaida/java-demo:v1.0

# 当前宿主机推送镜像到docker hub
docker push cuihaida/java-demo:v1.0

# 这样其他服务器就可以使用docker pull命令进行拉取了
docker pull cuihaida/java-demo:v1.0

2：本地镜像发布到阿里云

2.1：打包容器为镜像

在Docker中，你可以使用docker commit命令将一个正在运行的容器转换为镜像，或者使用docker save和docker load来导出和导入镜像。下面是一些具体的步骤和示例：

使用docker commit

1. 首先，启动一个容器（例如，使用docker run命令）。

   docker run -d --name my_container ubuntu /bin/sleep infinity
   

2. 然后，使用docker commit将该容器转换为镜像。

   docker commit my_container my_new_image
   

3. 此时，你可以使用docker images查看新的镜像。

   docker images
   

使用docker save和docker load

1. 首先，确保容器正在运行或已停止。

2. 使用docker save导出容器。

   docker save -o my_container.tar my_container
   

3. 然后，可以使用docker load来加载这个镜像。

   docker load -i my_container.tar
   

4. 加载后，你可以使用docker images查看新加载的镜像。

   docker images
   

2.2：进入阿里云开发者平台：

https://promotion.aliyun.com/ntms/act/kubernetes.html

创建仓库镜像

2.3：进入容器镜像服务

选择控制台，进入容器镜像服务

2.4：创建命名空间和仓库名称

个人版 -> 命名空间 -> 仓库名称

2.5：进入管理界面获得脚本

2.7：镜像推送

2.7.1：登录到阿里云registry

docker login 
	--username=[你的用户名] # 指定用户名
	registry.cn-hangzhou.aliyuncs.com # 阿里云registry

2.7.2：将镜像推送到registry

# 打上tag标签
docker tag 
	cea1bb40441c # 镜像id
	registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1 # 标签名称 & 版本

# 推送
docker push registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1

2.8：从阿里仓库下载别人的镜像

docker pull registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1

3：本地镜像发布到私有docker仓库

Docker Registry是官方提供的工具，可以用于构建私有镜像仓库

3.1：下载镜像Docker Registry

docker pull registry

3.2：运行私有库

docker run 
	-d # 后台启动
	-p 5000:5000  # 端口映射
	-v /zzyyuse/myregistry/:/tmp/registry  # 数据卷挂载，宿主机目录/zzyyuse/myregistry/，容器目录/tmp/registry
	--privileged=true # 私有化
	registry

默认情况，仓库被创建在容器的/var/lib/registry目录下，建议自行用容器卷映射，方便于宿主机联调

3.3：将指定容器构建成为镜像

docker commit 
	-m="ifconfig cmd add" 
	-a="zzyy" 
	a69d7c825c4f  # 容器id
	zzyyubuntu:1.2 # 镜像名称:版本号

3.4：curl验证私服镜像

curl -XGET http://192.168.111.162:5000/v2/_catalog

3.5：推送到私服

3.5.1：打标签

docker tag  
	zzyyubuntu:1.2  
	192.168.111.162:5000/zzyyubuntu:1.2 # 换成自己的IP

3.5.2：http支持

修改守护线程的配置文件使之支持http

修改完之后注意重启docker

3.5.3：推送到私服

docker push 192.168.111.162:5000/zzyyubuntu:1.2

推送完成可以使用curl验证私服库是否有这个

3.6：从私有仓库拉取到本地

docker pull 192.168.111.162:5000/zzyyubuntu:1.2

五：DockerFile

一种命令脚本，可以使用docker build通过dockerfile脚本创建镜像。

Dockerfile 是定义 Docker 容器镜像构建过程的文件，包括容器镜像使用的基础环境、容器内的依赖和文件、容器的配置、启动命令等。

有了 Dockerfile，我们就能很轻松地制作出自己的容器镜像。

虽然 Dockerfile 的写法并不复杂，但还是建议尽量不要自己写，直接去网上找个差不多的项目，复制粘贴别人的 Dockerfile 就足够了！

1：dockerFile指令集

官方文档：https://docs.docker.com/engine/reference/builder/#dockerfile-reference

1.1：FROM

指定基础镜像，指定这个镜像的母亲是谁

支持三种格式：

• FROM <image>
• FROM <image>:<tag>
• FROM <image>@<digest>

FROM指令必须指定且需要在Dockerfile其他指令的前面。

指定的基础image可以是官方远程仓库中的，也可以位于本地仓库。

后续的指令都依赖于该指令指定的image。

当在同一个Dockerfile中建立多个镜像时，可以使用多个FROM指令。

1.2：MAINTAINER

指定维护者的信息，告诉这个脚本谁在维护

格式为：

• MAINTAINER <name>

1.3：RUN

镜像构建的时候需要运行的命令

支持两种格式：

• RUN <command>
• RUN ["executable", "param1", "param2"]。

RUN <command> 在shell终端中运行命令

• 在Linux中默认是/bin/sh -c
• 在Windows中是 cmd /s /c

RUN ["executable", "param1", "param2"] 使用exec执行。

• 指定其他终端可以通过该方式操作，例如：RUN ["/bin/bash", "-c", "echo hello"]
• 该方式必须使用[“]而不能使用[‘]，因为该方式会被转换成一个JSON 数组。

1.4：CMD

指定容器时要运行的命令，为执行的容器提供默认值主要是

CMD支持三种格式：

• CMD ["executable","param1","param2"] (推荐使用)
• CMD ["param1","param2"] (为ENTRYPOINT指令提供预设参数)
• CMD command param1 param2 (在shell中执行)

CMD指令的主要目的是为执行容器提供默认值。

每个Dockerfile只有一个CMD命令，如果指定了多个CMD命令，那么只有一条会被执行

如果启动容器的时候指定了运行的命令，则会覆盖掉CMD指定的命令。

1.5：LABEL

为镜像添加元数据

格式为：

• LABEL <key>=<value> <key>=<value> <key>=<value> ...

使用 “和 \ 转换命令行，示例：

LABEL "com.example.vendor"="ACME Incorporated"
LABEL com.example.label-with-value="foo"
LABEL version="1.0"
LABEL description="This text illustrates \
that label-values can span multiple lines."

1.6：EXPOSE

为Docker容器设置对外的端口号

格式为：

• EXPOSE <port> [<port>...]

在启动时，可以使用-p选项或者-P选项。

# 映射一个端口示例
EXPOSE port1
# 相应的运行容器使用的命令
docker run -p port1 image
# 也可以使用-P选项启动
docker run -P image

# 映射多个端口示例
EXPOSE port1 port2 port3
# 相应的运行容器使用的命令
docker run -p port1 -p port2 -p port3 image
# 还可以指定需要映射到宿主机器上的某个端口号  
docker run -p host_port1:port1 -p host_port2:port2 -p host_port3:port3 image

1.7：ENV

指定环境变量

格式为：

• ENV <key> <value>
• ENV <key> = <value> ...

指定环境变量，会被后续RUN指令使用

在容器启动后：

• 可以通过docker inspect查看这个环境变量
• 也可以通过docker run --env <key> = <value> 来修改环境变量

ENV JAVA_HOME /path/to/java # 设置环境变量JAVA_HOME

1.8：ADD

copy文件，会自动进行解压操作

格式为：

• ADD <src>... <dest>
• ADD ["<src>",... "<dest>"]

从src目录复制文件到容器的dest。

其中src可以是Dockerfile所在目录的相对路径，也可以是一个URL，还可以是一个压缩包

⚠️ 注意下面的事项：

1. src必须在构建的上下文内，不能使用例如：ADD ../somethine /something ，因为docker build 命令首先会将上下文路径和其子目录发送到docker daemon
2. 如果src是一个URL，同时dest不以斜杠结尾，dest将会被视为文件，src对应内容文件将会被下载到dest
3. 如果src是一个URL，同时dest以斜杠结尾，dest将被视为目录，src对应内容将会被下载到dest目录
4. 如果src是一个目录，那么整个目录其下的内容将会被拷贝，包括文件系统元数据
5. 如果文件是可识别的压缩包格式，则docker会自动解压

1.9：COPY

• COPY <src>... <dest>
• COPY ["<src>",... "<dest>"] （shell中执行）

复制本地端的src到容器的dest。

和ADD指令类似，只是COPY不支持URL和压缩包。

1.10：ENTRYPOINT

指定Docker容器启动时执行的命令，可以多次设置，但是只有最后一个有效

格式为：

• ENTRYPOINT ["executable", "param1", "param2"]
• ENTRYPOINT command param1 param2

1.11：VOLUME

指定持久化的容器数据卷映射

格式为：

• VOLUME ["/data"]

使容器中的一个目录具有持久化存储数据的功能，该目录可以被容器本身使用，也可以共享给其他容器。

当容器中的应用有持久化数据的需求时可以在Dockerfile中使用该指令。

1.12：USER

设置启动容器的用户，默认是root用户。

格式为：

• USER 用户名

1.13：WORKDIR

切换目录指令

格式为：

• WORKDIR /path/to/workdir

类似于cd命令，对RUN、CMD、ENTRYPOINT生效。

1.14：ARG

定义一个变量

格式为：

• ARG <name>[=<default value>]

1.15：ONBUILD

指定当建立的镜像作为其他镜像的基础时，所执行的命令

格式为：

• ONBUILD [INSTRUCTION]

2：dockerFile示例

上面命令比较多，比较常用的有下面这几个：

例如，要基于Ubuntu镜像来构建一个Java应用，其Dockerfile内容如下：

# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录、容器内时区
ENV JAVA_DIR=/usr/local
ENV TZ=Asia/Shanghai
# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# 设定时区
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8
# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# 指定项目监听的端口
EXPOSE 8080
# 入口，java项目的启动命令
ENTRYPOINT ["java", "-jar", "/app.jar"]

有人提供了基础的系统加JDK环境，我们在此基础上制作java镜像，就可以省去JDK的配置了

# 基础镜像
FROM openjdk:11.0-jre-buster
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY docker-demo.jar /app.jar
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]

当Dockerfile文件写好以后，就可以利用命令来构建镜像了。

提前准备好一个demo项目及对应的Dockerfile：

首先，我们将docker-demo.jar包以及Dockerfile拷贝到虚拟机的/root/demo目录：

然后，执行命令，构建镜像：

# 进入镜像目录
cd /root/demo
# 开始构建
docker build -t docker-demo:1.0 .

命令说明：

• docker build : 就是构建一个docker镜像
• -t docker-demo:1.0 ：-t参数是指定镜像的名称（repository和tag）
• . : 最后的点是指构建时Dockerfile所在路径，由于我们进入了demo目录，所以指定的是.代表当前目录，也可以直接指定Dockerfile目录：

# 直接指定Dockerfile目录
docker build -t docker-demo:1.0 /root/demo

结果：

查看镜像列表：

# 查看镜像列表：
docker images
# 结果
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
docker-demo   1.0       d6ab0b9e64b9   27 minutes ago   327MB
nginx         latest    605c77e624dd   16 months ago    141MB
mysql         latest    3218b38490ce   17 months ago    516MB

然后尝试运行该镜像：

# 1.创建并运行容器
docker run 
	-d 
	--name dd 
	-p 8080:8080 
	docker-demo:1.0
# 2.查看容器
dps
# 结果
CONTAINER ID   IMAGE             PORTS                                                  STATUS         NAMES
78a000447b49   docker-demo:1.0   0.0.0.0:8080->8080/tcp, :::8090->8090/tcp              Up 2 seconds   dd
f63cfead8502   mysql             0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   Up 2 hours     mysql

# 3.访问测试
curl localhost:8080/hello/count