1. docker概念
1.1 镜像
我们都知道,操作系统分为 内核 和 用户空间。对于 Linux
而言,内核启动后,会挂载 root
文件系统为其提供用户空间支持。而 Docker 镜像(Image
),就相当于是一个 root
文件系统。比如官方镜像 ubuntu:18.04
就包含了完整的一套 Ubuntu 18.04 最小系统的 root
文件系统。
Docker 镜像 是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置等文件外,还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。镜像 不包含 任何动态数据,其内容在构建之后也不会被改变。
1.2 分层存储
因为镜像包含操作系统完整的 root
文件系统,其体积往往是庞大的,因此在 Docker 设计时,就充分利用 Union FS 的技术,将其设计为分层存储的架构。所以严格来说,镜像并非是像一个 ISO
那样的打包文件,镜像只是一个虚拟的概念,其实际体现并非由一个文件组成,而是由一组文件系统组成,或者说,由多层文件系统联合组成。
镜像构建时,会一层层构建,前一层是后一层的基础。每一层构建完就不会再发生改变,后一层上的任何改变只发生在自己这一层。比如,删除前一层文件的操作,实际不是真的删除前一层的文件,而是仅在当前层标记为该文件已删除。在最终容器运行的时候,虽然不会看到这个文件,但是实际上该文件会一直跟随镜像。因此,在构建镜像的时候,需要额外小心,每一层尽量只包含该层需要添加的东西,任何额外的东西应该在该层构建结束前清理掉。
分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层,然后进一步添加新的层,以定制自己所需的内容,构建新的镜像。
1.3 容器
镜像(Image
)和容器(Container
)的关系,就像是面向对象程序设计中的 类
和 实例
一样,镜像是静态的定义,容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
容器的实质是进程,但与直接在宿主执行的进程不同,容器进程运行于属于自己的独立的 命名空间。因此容器可以拥有自己的 root
文件系统、自己的网络配置、自己的进程空间,甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里,使用起来,就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。也因为这种隔离的特性,很多人初学 Docker 时常常会混淆容器和虚拟机。
前面讲过镜像使用的是分层存储,容器也是如此。每一个容器运行时,是以镜像为基础层,在其上创建一个当前容器的存储层,我们可以称这个为容器运行时读写而准备的存储层为 容器存储层。
容器存储层的生存周期和容器一样,容器消亡时,容器存储层也随之消亡。因此,任何保存于容器存储层的信息都会随容器删除而丢失。
按照 Docker 最佳实践的要求,容器不应该向其存储层内写入任何数据,容器存储层要保持无状态化。所有的文件写入操作,都应该使用 数据卷(Volume)、或者 绑定宿主目录,在这些位置的读写会跳过容器存储层,直接对宿主(或网络存储)发生读写,其性能和稳定性更高。
数据卷的生存周期独立于容器,容器消亡,数据卷不会消亡。因此,使用数据卷后,容器删除或者重新运行之后,数据却不会丢失
2. docker常用命令
万能查命令 --help
2.1 镜像相关
1. docker images -a:查看全部已下载镜像
2. docker search 镜像名:docker hub中查找镜像
3. docker rmi -f 镜像id:删除已下载的镜像
4. docker pull 镜像名:版本 : 拉取镜像
2.2 容器
1. docker run 镜像:启动一个镜像
相关参数:
--name="容器名":启动镜像,声明容器名
-d:后台运行
-it:交互的方式运行
-p 宿主机端口: 容器端口 :指定端口,就是容器的端口映射到宿主机的端口
-P:随机映射端口到宿主机的端口
-e:设置环境变量
-v 宿主机目录:容器目录:将容器的目录映射到宿主机,删除容器时,文件还能保留
--net:指定网络
2. docker ps:查看运行的容器
-a:查全部
-n=1:查最近运行的1个
-q:只显示容器编号
3. docker rm -f [容器id|容器名]:删除容器
4. docker logs [容器id|容器名]:查看容器运行日志
5. docker top [容器id|容器名]:查看容器进程
6. docker inspect [容器id|容器名]:查看容器详细信息
7. docker exec -it [容器id|容器名] [bash |sh |/bin/bash]:进入容器,新起的命令行
8. docker attach [容器id|容器名] :进入容器,当前命令行
9. docker cp 容器id:容器内路径 宿主机路径:复制容器内的文件到宿主机
10. docker stats [容器id|容器名]:容器cpu使用情况
3. Dockerfile
dockerfile是用于生成自己的自定义镜像
1. FROM:基础镜像
2. MAINTAINER:镜像是谁写的,姓名<邮箱>
3. RUN:镜像构建的时候运行的命令(在容器内运行)
4. ADD: 步骤,添加某个压缩包进入
5. WORKDIR:镜像的工作目录
6. VOLUME:挂载的目录
7. EXPOSE:保留端口配置
8. CMD:指定这个容器启动时运行的命令,only最后一个执行
9. ENTRYPOINT:指定这个容器启动时运行的命令,可以追加命令
10.ONBUILD:当构建一个dockerfile时就会运行,触发指令
11. COPY:类似ADD,将宿主机文件拷贝到镜像中
12. ENV:构建镜像的时候设置的环境变量
实战:gin框架打包为镜像,使用docker运行
gin代码:
package main
import "github.com/gin-gonic/gin"
func main() {
// 创建Gin默认引擎
router := gin.Default()
// 定义路由和处理函数
router.GET("/", func(c *gin.Context) {
c.JSON(200, gin.H{
"message": "Hello, World!",
})
})
// 启动Gin服务器
router.Run(":9000")
}
dockerfile:
FROM golang:1.18
ENV GO111MODULE on
RUN mkdir /code
WORKDIR /code
COPY . /code
RUN go build -o main .
EXPOSE 9000
ENTRYPOINT /code/main
构建镜像:docker build -f dockerfile -t gin_demo:1.0.1 .
运行:docker run -p 9000:9000 --name=gin_demo gin_demo:1.0.1
4. docker网络
docker可以通过网络进行容器之间的隔离,只有相同的网络内的容器,才能通过容器名互相ping通
docker network:网络相关命令
5. docker-compose
5.1 yaml文件相关关键字
docker-compose是独立于docker之外的项目,用于容器的编排,使用的是yaml文件进行步骤的书写,其中的关键字如下:
1. build:打包自己的代码为镜像
2. container_name:容器名
3. ports:端口映射
4. networks:指定网络
5. depends_on:指定在某容器启动后,再启动
6. image:指定镜像
7. volumes:文件映射
8. healthcheck:心跳检查,有固定写法,下方示例会有提供参考
9. ulimits:修改容器系统内部参数
10. environment:设置环境变量
11. env_file:使用配置文件的方式设置环境变量,文件后缀为.env
12. command:run 镜像后用来覆盖容器的默认命令
参考例子:
docker-compose.yaml
version: "3.0"
services:
demo:
build: # 打包自己的代码为镜像
context: demo # 上下文,指定dockerfile所在的目录
dockerfile: Dockerfile # 指定dockerfile文件
container_name: demo
ports:
- "8081:8081"
networks:
- hello
depends_on:
- tomcat01
tomcat01: # 服务名唯一
container_name: tomcat01 # 声明容器名
image: tomcat # 创建当前服务使用的镜像
ports: # 端口映射,必须使用引号,因为在compose中端口会解析为60进制,小于60的端口会解析错误,所以要用引号
- "8081:8080"
volumes: # 文件映射,数据卷共享
- /home/vick/docker_self/docker_test_compose/tomcat01/webapps:/usr/local/tomcat/webapps
networks: # 当前服务使用的网桥
- hello
depends_on: # 代表这个容器必须依赖哪些容器启动之后才能启动
- tomcat02 # 服务名
- mysql
- redis
healthcheck: # 心跳检测,向docker发送检测数据
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 1m30s
timeout: 10s
retries: 3
tomcat02: # 服务名唯一
container_name: tomcat02 # 声明容器名
image: tomcat # 创建当前服务使用的镜像
ports: # 端口映射,必须使用引号,因为在compose中端口会解析为60进制,小于60的端口会解析错误,所以要用引号
- "8082:8080"
volumes: # 文件映射,数据卷共享
- /home/vick/docker_self/docker_test_compose/tomcat02/webapps:/usr/local/tomcat/webapps
networks: # 当前服务使用的网桥
- hello
# sysctls: # 用来修改容器中系统内部参数 并不是必须的,有些容器启动受限于内部系统
# - net.core.somaxconn=1024
# - net.ipv4.tcp_syncookies=0
ulimits: # 用来修改容器中系统内部进程数限制
nproc: 65535
nofile:
soft: 20000
hard: 40000
mysql:
container_name: mysqlSelf
image: mysql:5.7
ports:
- "3306:3306"
volumes:
- /home/vick/docker_self/docker_test_compose/mysql/data:/var/lib/mysql
- /home/vick/docker_self/docker_test_compose/mysql/conf:/etc/mysql/conf.d
# environment: # 设置环境变量,用于mysql启动的时候输入
# - MYSQL_ROOT_PASSWORD=root # 设置mysql的密码
env_file: # 用来将environment环境中配置放入指定配置文件,文件必须为.env,内容必须为key=value格式
- ./mysql.env
networks:
- hello
redis:
container_name: redis
image: redis:5.0
ports:
- "6379:6379"
volumes:
- /home/vick/docker_self/docker_test_compose/redis/data:/data
command: "redis-server --appendonly yes" # run 镜像后用来覆盖容器的默认命令
networks:
- hello
# networks: # 定义服务用的网桥
# hello: # 定义上面服务用的网桥 默认创建的是bridge
# 使用自定义网桥
networks:
hello: # 定义上面服务用的网桥 默认创建的是bridge
external:
true # 使用外部指定网桥,注意:网桥必须存在
mysql.env
MYSQL_ROOT_PASSWORD=root
5.2 相关命令
docker-compose -f 指定yaml文件 up -d : 启动容器,后台启动
docker-compose -f 指定yaml文件 down : 停止,必移除自己创建的网桥
docker-compose -f 指定yaml文件 ps : 列出当前compose启动的容器
docker-compose -f 指定yaml文件 restart : 重启容器
docker-compose -f 指定yaml文件 stop : 停止容器
docker-compose -f 指定yaml文件 rm : 删除容器, + -vf 表示强制删除,并删除对应的挂载卷
docker-compose -f 指定yaml文件 start : 启动容器
docker-compose -f 指定yaml文件 exec : 进入指定容器
docker-compose -f 指定yaml文件 top : 查看启动的容器进程
docker-compose -f 指定yaml文件 unpause : 恢复暂停中的容器
docker-compose -f 指定yaml文件 pause : 暂停容器
docker-compose -f 指定yaml文件 logs : 查看启动日志
6. gin打包容器部署实战
gin在主要代码,main.go
package main
import "github.com/gin-gonic/gin"
func main() {
// 创建Gin默认引擎
router := gin.Default()
// 定义路由和处理函数
router.GET("/", func(c *gin.Context) {
c.JSON(200, gin.H{
"message": "Hello, World!",
})
})
// 启动Gin服务器
router.Run(":9000")
}
方式一:直接打包,缺点镜像会巨大
FROM golang:1.18
ENV GO111MODULE on
RUN mkdir /code
WORKDIR /code
COPY . /code
RUN go build -o main .
EXPOSE 9000
ENTRYPOINT /code/main
方式二:多阶段构建,解决镜像过大问题,但是下载使用的流量加大。这边建议使用linux的基础镜像作为二次构建的基础镜像,alpine镜像无法运行打包后的gin二进制文件
# 多段构建
# 第一阶段
FROM golang:1.18 AS builder
ENV GO111MODULE on
RUN mkdir /code
WORKDIR /code
COPY . /code
RUN go build -o main .
# 第二阶段
FROM ubuntu:18.04
RUN mkdir /code
WORKDIR /code
COPY --from=builder /code /code
EXPOSE 9000
ENTRYPOINT ["./main"]
方式三:先在环境中go build,再将二进制文件打包容器。可以解决无需重复下载包,下载两次镜像的文件问题
# go先build
# 再将代码打包镜像
FROM ubuntu:18.04
RUN mkdir /code
WORKDIR /code
COPY ./main /code
EXPOSE 9000
ENTRYPOINT ["./main"]
docker-compose启动的话,同样需要有Dockerfile文件的存在
version: "3"
services:
gin_demo:
build:
context: "./" # dockerfile所在的目录
dockerfile: "Dockerfile" # 指定dockerfiel 文件
container_name: "gin_demo"
ports:
- "9000:9000"