Docker入门教程

一、Docker概述

1. 什么是容器技术？

容器是一个允许我们在资源隔离的过程中，运行应用程序和其依赖项的 、轻量的 、操作系统级别的虚拟化技术， 运行应用程序所需的所有必要组件都打包为单个镜像，这个镜像是可以重复使用的。当镜像运行时，它是运行在独立的环境中，并不会和其他应用共享主机操作系统的内存、CPU或磁盘。这保证了容器内的进程不会影响到容器外的任何进程。

2. 什么是Docker

Docker官网地址 : https://www.docker.com/

Docker文档地址 : https://docs.docker.com/

Docker镜像仓库地址 : https://hub.docker.com/

Docker是一个开源的应用容器引擎，让开发者把他们的应用以及依赖打包到一个可移植的镜像中（打包），然后发布到任何流行的Linux或Windows操作系统的机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口（隔离）。Docker底层用的Linux的cgroup和namespace这两项技术来实现应用隔离，一个完整的Docker有以下几个部分组成：

• Docker Client：客户端。
• Docker Daemon：守护进程。
• Docker Image：镜像。
• Docker Container：容器。

3. 为什么要使用Docker

Docker可以解决项目部署问题，比如 传统方式的项目部署会遇到以下问题：

• 组件兼容问题。（比如项目依赖jdk8的环境，如果给他降jdk7就会遇到各种兼容问题）
• 操作系统环境不同问题。（比如测试环境在centos，生产环境迁到ubuntu，就会遇到系统兼容问题）

1、Docker如何解决组件兼容问题？

Docker会将应用的Libs(函数库)、Deps(依赖)、配置与应用一起打包。

将每个应用放到一个隔离的容器去运行，避免相互干扰。（沙箱机制）

2、Docker如何解决操作系统不同问题？

Docker会将应用程序与所需要调用的操作系统函数库一起打包。（会占用很多资源）

Docker运行到不同操作系统时，直接基于打包的系统函数库，借助于操作系统的Linux内核来运行。

操作系统基本结构：

• 计算机硬件：例如CPU、内存、硬盘、网卡等
• 系统内核：所有Linux发行版的内核都是Linux，例如CentOS、Ubuntu、Fedora等。内核可以与计算机硬件进行交互，对外提供内核指令，用于操作计算机硬件。
• 系统应用：操作系统本身提供的应用、函数库。这些函数库是对内核指令的封装，使用更加方便。

4. Docker和虚拟机的对比

首先两者都是用来做隔离的，Docker作为一种新兴的虚拟化方式， 跟传统的虚拟化方式相比具有众多的优势。

1、更高效的利用系统资源：

• 由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker对系统资源的利用 率更高。无论是应用执行速度、内存损耗或者文件存储速度，都要比传统虚拟机技术更高效。因此，相比虚拟机技术，一个相同配置的主机，往往可以运行更多数量的应用。

2、更快速的启动时间：

• 传统的虚拟机技术启动应用服务往往需要数分钟，而 Docker 容器应用，由于直接运行于宿主内核，无需启动完整的操作系统，因此可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。

3、一致的运行环境：

• 开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环境不一致，导致有些bug并未在开发过程中被发现。而 Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 「这段代码在我机器上没问题啊」 这类问题。

4、持续交付和部署：

• 对开发和运维（DevOps）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。
• 使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员可以通过 Dockerfile 来进行镜像构建，并结合 持续集成(Continuous Integration) 系统进行集成测试， 而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 持续部署(Continuous Delivery/Deployment) 系统进行自动部署。
• 而且使用 Dockerfile 使镜像构建透明化，不仅仅开发团队可以理解应用运行环境，也方便 运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像。

5、更轻松的迁移：

• 由于Docker确保了执行环境的一致性，使得应用的迁移更加容易。Docker可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。 因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行 环境的变化导致应用无法正常运行的情况。

6、更轻松的维护和扩展：

• Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，以及应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的官方镜像，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。

对比传统虚拟机总结如下：

艾玛，真香！！！

搞起来！！！

5. Docker相关概念

镜像、容器、仓库（重点）

镜像（Image）：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。（安装包 ）

容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器进程做隔离，对外不可见。

仓库（repository）：仓库就是存放镜像的地方！仓库分为公有仓库和私有仓库！

一切应用最终都是代码组成，都是硬盘中的一个个的字节形成的文件。只有运行时，才会加载到内存，形成进程。

镜像就是把一个应用在硬盘上的文件、及其运行环境、部分系统函数库文件一起打包形成的文件包。这个文件包是只读的。

容器是将这些文件中编写的程序、函数加载到内存中运行，形成进程(就是容器)，Docker会给容器进程做隔离(守护进程)。

一个镜像可以启动多个容器。

6. DockerHub

DockerHub镜像仓库地址：https://hub.docker.com/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2yqi1jGl-1676658332218)(docker.assets/image-20230214234712523.png)]

DockerHub：是Docker官方提供的镜像仓库（托管平台）。这样的平台称为Docker Registry。

国内也有类似DockerHub的镜像托管平台：

• 网易云镜像服务： https://c.163yun.com/hub
• 阿里云镜像服务：https://cr.console.aliyun.com/
• 私有云：自己公司用的。
• 等等

7. Docker架构

我们要使用Docker来操作镜像、容器，就必须要安装Docker。

Docker是一个CS架构的程序，由两部分组成：

• 服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等。

• 客户端(client)：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

总结

镜像：类似安装包，它将应用程序及其依赖、环境、配置打包在一起。

容器：镜像运行起来就是容器，一个镜像可以运行多个容器。

Docker结构：

• 服务端：接收命令或远程请求，操作镜像或容器。

• 客户端：发送命令或者请求到Docker服务端。

DockerHub：是一个镜像托管的服务器，类似的还有阿里云镜像服务、网易云镜像服务等等，统称为DockerRegistry。

二、安装Docker

1. 安装Docker

环境准备：CentOS7（系统内核要求是3.10以上的）、SSH客户端

帮助文档 : https://docs.docker.com/

1、查看系统内核（系统内核要求是3.10以上的）

uname -r

2、如果之前安装过旧版本的Docker，可以使用下面命令进行卸载Docker：

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

3、安装yum工具

yum install -y yum-utils

4、 设置阿里云镜像源

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

5、更新镜像源

sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

6、 更新yum软件包索引

yum makecache fast

7、安装docker-ce社区版 ，免费版本 （ ee企业版）

yum install -y docker-ce

8、关闭防火墙

systemctl stop firewalld  #关闭防火墙
systemctl disable firewalld #禁止开机启动
systemctl status firewalld

9、启动docker

systemctl start docker  # 启动docker服务
systemctl enable docker.service #设置docker开机自动启动

• 停止docker服务：systemctl stop docker
• 重启docker服务：systemctl restart docker

10、查看docker版本号，测试是否启动成功。

docker -v

ok，docker已经成功运行起来啦！

2. 配置阿里云镜像加速

华为云容器镜像服务 ：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

阿里云镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

1、登录阿里云找到容器服务

2、找到镜像加速地址

3、配置镜像加速，全选下面的代码执行即可。

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://bbc8rnyr.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

4、 查看镜像加速配置

cat /etc/docker/daemon.json

ok，到这里阿里云镜像加速已经配置成功啦！

三、Docker常用命令

帮助文档的地址：https://docs.docker.com/reference/

1. 帮助命令

docker -v	   # 显示docker的版本号

docker version 	   # 显示docker的版本信息

docker info		   # 显示docker的系统信息,包括镜像和容器的数量

docker [COMMAND] --help  # 帮助命令 (COMMAND,命令),例如 docker save --help

2. 镜像操作命令

镜名称一般分两部分组成：[repository]:[tag]。

• 镜像名:版本， 例如：mysql:5.7。

如果拉取镜像不指定版本，默认是latest，代表最新版本的镜像。（最好用具体版本的镜像，方便查看版本）

镜像常用命令：

• 获取镜像：
  • 本地构建：docker bulid
  • 拉取镜像：docker pull 镜像名称
• 查看镜像： docker images
• 删除镜像： docker rmi 镜像名称或镜像id
• 推送镜像： docker push 镜像名称
• 导出镜像： docker save -o 文件名.tar 镜像名称
• 加载镜像： docker load -i 文件名.tar
• 加载镜像： docker load -i -q 文件名.tar （不输出日志）

1、查看镜像：

docker images

2、拉取镜像，mysql5.7

docker pull mysql:5.7

3、将mysql镜像打成压包，如果别的同学网不好，你可以把这个包丢给她。

docker save -o mysql.tar mysql:5.7

4、删除mysql镜像

docker rmi mysql:5.7 

5、加载镜像，mysql.tar

 docker load -i mysql.tar 

3. 容器操作命令

容器保护三个状态：

• 运行：进程正常运行
• 暂停：进程暂停，CPU不再运行，并不释放内存
• 停止：进程终止，回收进程占用的内存、CPU等资源

容器常用命令：

• docker run：创建并运行一个容器，处于运行状态。

  • docker run --name [容器名] -p 宿主机端口号:容器内部端口号 -d [镜像名称]

• docker pause：让一个运行的容器暂停。

• docker unpause：让一个容器从暂停状态恢复运行。

• docker stop：停止一个运行的容器。

• docker start：让一个停止的容器再次运行。

• docker restart：重启容器。

• docker rm：删除一个容器。

• docker rm -f ：强制删除容器。

• docker rm -f $(docker ps -qa)： 删除所有dokcer容器 (包括正在运行的和已停止的容器)

• docker ps：查看正在运行的容器。

• docker ps -a：查看所有容器。

• docker logs 容器名 ：查看容器日志。

• docker logs -f 容器名 ：持续查看容器日志。

• 进入容器：docker exec -it 容器名 bash。（execute，执行）

• 把容器设置开机自启：docker update --restart=always 容器名

• 查询指定名称开头的容器id：docker ps -a -q --no-trunc --filter name=^/xxx 。（这里xxx表示容器开头名称）

• 组合命令启动指定名称开头的容器：docker start docker ps -a -q --no-trunc --filter name=^/xxx。

扩展：

docker run -it IMAGES_NAME  #会创建前台进程，但是会在输入exit后终止进程。

docker attach DOCKER_ID   #会通过连接stdin，连接到容器内输入输出流，会在输入exit后终止进程.

docker exec -it DOCKER_ID /bin/bash #会连接到容器，可以像SSH一样进入容器内部，进行操作，可以通过exit退出容器，不影响容器运行。

#以上几种方式均可通过输入Ctrl+P+Q把前台容器放入后台运行，不终止进程。

示例练习

1、下载nginx镜像，创建并运行一个容器，容器名为nginx1

# 下载最新版的nginx
docker pull nginx

# 创建并运行一个容器,容器名为nginx1,对外提供的端口是800,容器内部端口是80, -d表示后台启动
docker run --name nginx1 -p 800:80 nginx

• docker run ：创建并运行一个容器。
• –name : 给容器起一个名字，比如叫做nginx1。
• -p ：端口映射。
• -d：后台运行容器。
• nginx：镜像名称，例如nginx。

浏览器测试访问：http://192.168.112.129:800/

2、进入nginx1容器，修改nginx首页内容

docker exec -it nginx1 bash

• docker exec ：进入容器内部，执行一个命令。

• -it : 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互。

• mn ：要进入的容器的名称。

• bash：进入容器后执行的命令，bash是一个linux终端交互命令。

# 操作文本命令
sed -i -e 's#Welcome to nginx#白豆五欢迎您#g' -e 's#<head>#<head><meta charset="utf-8">#g' index.html

• -e 执行多个文本替换。

浏览器再次访问：http://192.168.112.129:800/

扩展：redis容器启动命令

# 运行redis容器
docker run --name redis1 -p 6379:6379 -d redis:7.0.0 redis-server --appendonly yes

# --appendonly yes   开启AOF(Append Only File)持久化

# 进入容器
docker exec -it redis1 bash

4. 练习

使用Docker安装一些常用软件。

4.1 安装Redis

1、下载redis镜像

docker pull redis:6.2.8

2、创建并运行redis容器

docker run --name redis1 -p 6379:6379 -d redis:6.2.8 redis-server --appendonly yes

• redis-server 启动redis服务
• –appendonly yes 开启持久化

注意：一定要关闭防火墙，或者开放端口(在虚拟机上、或者服务器官网的安全组中添加)，不然我们windows主机无法访问docker的redis容器。

3、进入redis容器

docker exec -it redis1 bash

4、启动redis客户端(命令行工具)

redis-cli 

ok，到这里redis就安装成功了。

4.2 RabbitMQ单机部署

1、下载RabbitMQ镜像

docker pull rabbitmq:3.8-management

2、安装RabbitMQ容器

docker run \
 -e RABBITMQ_DEFAULT_USER=admin \
 -e RABBITMQ_DEFAULT_PASS=123456 \
 -v mq-plugins:/plugins \
 --name mq1  \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8-management

• \ 代表换行，要执行多行命令
• -e 指定环境变量
• -e RABBITMQ_DEFAULT_USER=admin 用户名
• -e RABBITMQ_DEFAULT_PASS=123456 密码
• -v 挂载目录或文件 (数据卷)
• -p 15672:15672 用于页面使用的端口 (管理员页面)
• -p 5672:5672 用于生产和消费端使用的端口（通信端口，也就是在代码里使用）
• -d 后台运行
• –name mq1 容器名字
• –hostname mq1 （RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；

3、测试访问RabbitMQ管理页面：http://ip:15672

消息队列模型:

• 基本模型：简单队列、工作队列(work)模型。
• 发布/订阅模型：广播、路由、主题。（需要依赖交换机）

4.3 安装Ubuntu

1、拉取镜像

docker pull ubuntu

2、安装ubuntu容器

docker run -it ubuntu /bin/bash

3、强制删除运行的容器

docker rm -f 容器名称或容器id

4、删除镜像

docker rmi ubuntu

四、Docker可视化工具

Portainer是一个可视化的容器镜像的图形管理工具，利用Portainer可以轻松构建，管理和维护Docker环境。 而且完全免费，基于容器化的安装方式，方便高效部署。

官方安装说明：https://www.portainer.io/installation/

1、安装Portainer

docker run -d -p 9000:9000 \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
--privileged=true \
--name prtainer-test \
portainer/portainer

• –privileged=true 打开root权限

2、浏览器访问Docker管理界面：http://192.168.112.129:9000/

① 创建账号：

设置登录密码，长度最少8位，方便记忆我就设置成12341234啦。

② 选择管理本地docker环境

③ 进入docker管理面板：

五、数据卷

之前修改容器内部文件，需要进入容器里面才能修改，操作非常麻烦。

当我们删除容器时，容器里的数据就丢失了。（容器和数据是耦合在一起的，不可复用，升级维护困难）

解决方案：使用数据卷挂载目录。

数据卷（volume）：是一个虚拟目录，指向宿主机文件系统中的某个目录。（然后让容器和数据卷关联）

作用：让容器外面的目录和容器里面的目录进行关联。

一旦完成数据卷挂载，对容器的一切操作都会作用在数据卷对应的宿主机目录。

这样，我们操作外面的宿主机目录，就等同于操作容器内的目录。

即使我们把容器干掉，数据依然在外面的宿主机目录中保留。

数据卷操作相关的命令：

docker volume 【COMMAND】

• docker volume create：创建数据卷。
• docker volume ls：查看所有数据卷。
• docker volume inspect：查看数据卷详细信息，包括关联的宿主机目录位置。
• docker volume rm：删除指定数据卷。
• docker volume prune：删除所有未使用的数据卷。

1. 创建和查看数据卷

示例：创建一个数据卷，并查看数据卷在宿主机的目录位置

创建数据卷：

# 语法docker volume create [数据卷名称]
docker volume create abcd

查看所有数据卷：

docker volume ls

查看数据卷详细信息卷：

docker volume inspect html

2. 挂载数据卷

我们在创建容器时，可以通过 -v 参数来挂载一个数据卷到某个容器内目录，命令格式如下：

docker run \
  --name mn \
  -v html:/usr/share/nginx/html \
  -p 8080:80
  nginx \

这里的-v就是挂载数据卷的命令：

• \ ：表示多行输入。

• -v html:/root/htm ：把html数据卷挂载到容器内的/usr/share/nginx/html这个目录中。

• 数据卷不存在时会自动创建。（手动创建数据卷再挂载也可以）

• 若数据卷中没有文件，会将容器目录中的文件挂载到数据卷中。

• 若数据卷中有文件，会将数据卷中的文件覆盖容器目录中。

示例：给nginx挂载数据卷

1、启动容器并挂载目录

# 语法:docker run --name 容器名称 -v 数据卷:容器指定目录 -p 80:80 -d 镜像名称或id
docker run --name nginx1 -v html:/usr/share/nginx/html -p 80:80 -d nginx

2、进入html数据卷所在位置，并修改HTML内容

# 查看html数据卷的位置
docker volume inspect html
# 进入该目录
cd /var/lib/docker/volumes/html/_data
# 修改文件
vi index.html

3. 挂载目录

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上。挂载目录和挂载数据卷类似，语法如下：

• 挂载数据卷：-v [数据卷名称]:[容器内目录]。
• 目录挂载：-v [宿主机目录]:[容器内目录]。
• 文件挂载：-v [宿主机文件]:[容器内文件]。

数据卷挂载与目录挂载的区别：

• 数据卷挂载耦合度低（使用目录别名，即数据卷），由docker来管理目录，但是目录较深，不好找。（适合数据量小的）
• 目录挂载耦合度高（需要写完整目录），需要我们自己管理目录，不过目录更容易查找。（适合数据量大的）

示例：创建并运行一个MySQL容器，将宿主机目录直接挂载到容器指定目录中。

1、下载MySQL镜像

docker pull mysql:5.7

2、创建目录（存mysql数据和配置文件）

mkdir -p /tmp/mysql/data
mkdir -p /tmp/mysql/conf

3、在虚拟机/tmp/mysql/conf目录下，创建hmy.conf文件：

[mysqld]
skip-name-resolve
character_set_server=utf8 
datadir=/var/lib/mysql

• skip-name-resolve 禁用dns解析。
• character_set_server=utf8 设置字符集。
• datadir=/var/lib/mysql 容器内部存数据的目录

3、启动mysql：

docker run \
--name mysql1 \
--restart=always \
-e MYSQL_ROOT_PASSWORD=root \
-e TZ=Asia/Shanghai \
-p 3306:3306 \
-v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
-v /tmp/mysql/data:/var/lib/mysql \
-d \
mysql:5.7

• -p 3306:3306 端口映射。
• -e MYSQL_ROOT_PASSWORD=root ，密码设置为root。
• -e TZ=Asia/Shanghai 设置时区。
• –restart=always 开机自动启动。
• -v /tmp/mysql/data:/var/lib/mysql 挂载数据存储位置。
• -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf 挂载配置文件。
• -d 后台运行。

六、Dockerfile自定义镜像

文档地址： https://docs.docker.com/engine/reference/builder

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明，然后每一条指令都会形成一层。如 基础层FROM、入口层ENTRYPOINT。

1. 基于Ubuntu构建Java项目

需求：基于Ubuntu镜像构建一个新镜像，运行一个Java项目。

1、新建一个空文件夹docker-demo:

mkdir -p /test/docker-demo

cd /test/docker-demo/

2、上传一个测试项目demo.jar到docker-demo这个目录:

3、在docker-demo目录中，下载一个linux版jdk（上传文件到这个目录也可以）

wget https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz

4、在docker-demo目录中，创建Dockerfile文件：

vi Dockerfile

配置文件内容如下：（使用Dockerfile打包镜像）

# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local

# 拷贝jdk和java项目到指定目录
COPY ./jdk-8u202-linux-x64.tar.gz $JAVA_DIR/
COPY ./demo.jar /tmp/app.jar

# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk-8u202-linux-x64.tar.gz \
 && mv ./jdk1.8.0_202 ./java8

# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin

# 暴露端口
EXPOSE 8089

# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

5、在docker-demo目录下，运行docker build命令：

docker build -t javaweb:1.0 .

参数详解：

• docker build ：构建镜像；（前提：当前目录必须要有Dockerfile文件）
• -t ：指定构建的镜像名和版本，例如 javaweb:1.0；
• . ：表示使用当前目录下的Dockerfile构建。

查看本机镜像:

6、运行容器

docker run --name web1 -p8089:8089 -d javaweb:1.0

测试访问： http://ip:8089/hello/

2. 基于java8构建Java项目

上面的方式比较麻烦，而且打包后的镜像也比较大。所以大多数情况下，我们可以在一些安装部分软件的基础镜像上做改造。

基于java:8-alpine镜像，将一个Java项目构建为镜像。

Dockerfile文件内容如下：

# 基于java:8-alpine作为基础镜像
FROM java:8-alpine

# 将demo.jar拷贝到镜像中
COPY ./demo.jar /tmp/app.jar

# 暴露端口
EXPOSE 8089

# 编写入口ENTRYPOINT,java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

构建镜像操作步骤同上。

小节：

• Dockerfile的本质是一个文件，通过指令描述镜像的构建过；

• Dockerfile的第一行必须是FROM，从一个基础镜像来构建；

• 基础镜像可以是基本操作系统，如Ubuntu。也可以是其他人制作好的镜像，例如：java:8-alpine。

七、Docker Compose

docker-compose常用命令：https://blog.csdn.net/weixin_44336161/article/details/126446338

1. Docker Compose概述

Docker Compose是一个服务编排工具（定义和运行多容器的docker应用工具），可以帮我们快速的部署分布式应用，它还提供用于管理容器化应用的完整开发周期的命令，包括服务构建、启动和停止。

使用步骤如下：

• 利用Dockerfile定义运行环境镜像；
• 使用docker-compose.yml定义组成应用的各个服务；（定义启动顺序和关联关系）
• 在docker-compose.yml文件所在目录，运行docker-compose up 启动应用。

2. Docker Compose安装与卸载

1、安装Docker Compose：

# 1、安装
# 方式一:从Github上下载它的二进制包进行安装，安装后的文件大概12m左右（github下载速度稍微有点慢）
curl -L https://github.com/docker/compose/releases/download/1.29.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# 方式二:快速安装DockerCompose
curl -L https://get.daocloud.io/docker/compose/releases/download/1.29.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

# 2、为docker-compose文件添加可执行权限
chmod +x /usr/local/bin/docker-compose

# 3、查看版本信息
docker-compose -version

重启docker服务:

systemctl restart docker.service

2、卸载Docker Compose：

# 直接删除/usr/local/bin/docker-compose文件即可
rm /usr/local/bin/docker-compose

3. Docker Compose使用

1、创建docker-compose目录

mkdir /docker-compose
cd /docker-compose

2、编写docker-compose.yml文件：（编写容器相关配置）

version: '3'
services:
  rabbitmq:
    image: rabbitmq:3.8-management      # 镜像文件
    container_name: rabbitmq            # 容器名为'rabbitmq'
    hostname: my-rabbit                 # 主机名(集群的时候需要这个)
    restart: always                     # 设置docker重启时容器也重启 
    environment:                        # 设置环境变量,相当于docker run命令中的-e
      TZ: Asia/Shanghai                 
      LANG: en_US.UTF-8                 
      RABBITMQ_DEFAULT_USER: admin
      RABBITMQ_DEFAULT_PASS: 123456 
    volumes:                            # 数据卷挂载路径设置,将本机目录映射到容器目录
      - "./rabbitmq/data:/var/lib/rabbitmq"
      - "./rabbitmq/log:/var/log/rabbitmq"   # 防止log日志报failed to open log file
    ports:                              # 配置端口映射
      - "5672:5672"                     # 生产者、消费者通信的端口
      - "15672:15672"                   # 管理面板的端口

3、在/docker-compose目录下，使用docker-compose命令启动容器

docker-compose up

八、扩展

1. 自定义dps命令，通过docker ps查询指定列

# 修改环境变量
vim ~/.bashrc

# 在底部添加如下内容, 然后wq保存退出
alias dps='docker ps --format "table{{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"'

# 让环境重新生效
source ~/.bashrc

文章来源地址https://www.toymoban.com/news/detail-778406.html

到了这里，关于Docker入门教程的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！