Docker基础知识

最新推荐文章于 2025-12-20 22:03:03 发布
原创 最新推荐文章于 2025-12-20 22:03:03 发布 · 449 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#docker #容器 #运维

Docker

Docker入门

Docker的概述

Docker介绍

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows操作系统的机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口，容器之间互相隔离

一个完整的Docker有以下几个部分组成：

  1. DockerClient客户端
  2. Docker Daemon守护进程（一直运行在服务器上）
  3. Docker Image镜像
  4. DockerContainer容器

Docker的历史

在2010年，美国的几个IT行业的年轻人成立一家dotCloud的小型创业公司，做一写pass（Platform as a service）的云计算服务，LXC有关的容器技术，他们将自己的技术（容器化技术）命名为Docker

在当时，dotCloud并不被人关注，所以就慢慢做不下去，于是乎，这几个年轻人就将自己的项目开源

在2013年，Docker的创始人Solomon Hykes将Docker开源到GitHub上，Docker项目一经发布，就迅速爆火，越来越多的人就发现了Docker的优点

在2014，Docker 1.0版本横空出世！

VM与Docker的区别

在这里插入图片描述

相较于VM来说，Docker并没有在源宿主机上在创建一个完整的虚拟机环境，而是安装一些必要的启动环境，极大地减少了内存消耗，减少了启动时间

其他相关知识

pass服务：https://www.ibm.com/cn-zh/cloud/learn/paas

Linux容器：https://www.redhat.com/zh/topics/containers/whats-a-linux-container

Ubuntu安装Docker

我用的是Ubuntu所以只写了Ubuntu安装Docker的方式，CentOS或者Windows安装Docker，请看官方文档

CentOS：https://docs.docker.com/engine/install/centos/

Windows：https://docs.docker.com/desktop/install/windows-install/

卸载之前docker

sudo apt-get remove docker docker-engine docker.io containerd runc

通过仓库下载Docker

建立仓库

  1. Update the apt package index and install packages to allow apt to use a repository over HTTPS:

    $ sudo apt-get update

$ sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

  2. Add Docker’s official GPG key:

    $ sudo mkdir -m 0755 -p /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

  3. Use the following command to set up the repository:

    $ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

下载Docker引擎

安装最新版本的docker-ce
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
安装指定版本

  1. 查看以往版本

    # List the available versions:
apt-cache madison docker-ce | awk '{ print $3 }'
5:20.10.16~3-0~ubuntu-jammy
5:20.10.15~3-0~ubuntu-jammy
5:20.10.14~3-0~ubuntu-jammy
5:20.10.13~3-0~ubuntu-jammy

  2. 选择下载指定版本docker

    VERSION_STRING=5:20.10.13~3-0~ubuntu-jammy
sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-buildx-plugin docker-compose-plugin

检查下载情况

  1. 使用sudo docker version查看docker版本
  2. 使用sudo docker run hello-world查看docker是否能运行

出现了确定信息后，说明docker下载成功

Ubuntu卸载Docker引擎

  1. Uninstall the Docker Engine, CLI, containerd, and Docker Compose packages:

    $ sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

  2. Images, containers, volumes, or custom configuration files on your host aren’t automatically removed. To delete all images, containers, and volumes:

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

You must delete any edited configuration files manually.

Docker下载源设置

将国外的镜像源修改成国内的镜像源

  1. 创建/etc/docker/daemon.json文件

    sudo vim /etc/docker/daemon.json

  2. 添加阿里云镜像源地址

    {
"registry-mirrors":[
"https://kfwkfulq.mirror.aliyuncs.com",
"https://2lqq34jg.mirror.aliyuncs.com",
"https://pee6w651.mirror.aliyuncs.com",
"https://registry.docker-cn.com",
"http://hub-mirror.c.163.com"
],
"dns":["8.8.8.8","8.8.4.4"]
}

  3. 重启Docker服务

    sudo service docker restart

  4. 查看Docker镜像源地址

    sudo docker info|grep Mirrors -A 1
# 查看详情信息
docker info

Docker原理

hello-world加载原理

第一步：我们通过客户端向Docker Server发送了一条docker run的命令。
第二步：Docker Server会查看本地是否有对应的镜像，如果有的话直接进入第四步，否则进入第三步。
第三步：Docker 会去镜像仓库中下载对应的image到本地。
第四步：拥有了镜像，Docker将镜像运转起来，成为容器，这其中最重要的会为运行起来的容器分配相应的运行需要的资源，如网络，存储，CPU，内存等

Docker三要素

在这里插入图片描述

镜像

镜像是Docker的核心，是基于联合文件系统的一种层式结构。由一系列指令构建，是一种轻量级、可执行的独立软件包，用于打包软件运行环境和基于运行环境开发的软件（代码、运行时、库、环境变量和配置文件）

**联合文件系统(UnionFS)**是一种分层、轻量级、高性能的文件系统。它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一虚拟文件系统下。Union文件系统是Docker镜像的基础

在这里插入图片描述

Docker镜像（image）就是一个只读的模板，镜像可以用来创建Docker容器，一个镜像可以创建很多容器

镜像分层的优势就是实现资源共享：

  • 通过引入分层技术，可以增加镜像复用度，减少磁盘占用
  • 同时可以实现差分上传下载，加快镜像pull、push性能

例如：当你需要下载一个镜像时，该镜像包含了你原来的一经下载过的镜像，那么已经下载过的镜像将不在下载，而是复用

容器

  • Docker利用容器（container）独立运行的一个或者一组应用。

  • 容器是利用镜像创建的运行实例（相对于Java中的类和对象的概念）

  • 容器可以被启动、开始、停止、删除

  • 每个容器都是互相隔离的，保证安全的平台

  • 可以把容器看做是一个简易版的Linux环境 (包括root用户名权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序

  • 容器的定义和镜像几乎是一模一样的，也是一堆层的统一视角， 唯一区别的是容器的最上面那一层是可读可写的

  • 容器是镜像启动或执行阶段。Docker中的每个容器都包含了一个软件镜像，该镜像可以被创建、启动、关闭、重启和销毁

仓库

仓库（repository）是集中存放镜像文件的场所 。最大的公开仓库是docker hub（ https://hub.docker.com/）， 存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

Docker Hub中有两种类型的仓库：用户仓库(user repository)和顶层仓库(top-level repository)。用户仓库的镜像都是由Docker用户创建的，而顶层仓库则是由Docker内部的人来管理的

用户仓库的命名由用户名和仓库名两部分组成，如：jamtur01/puppet。用户名：jamtur01，仓库名：puppet

顶层仓库只包含仓库名部分，如ubuntu仓库。顶层仓库由Docker公司和由选定的能提供优质基础镜像的厂商（如Fedora团队提供了fedora镜像）管理，用户可以基于这些基础镜像构建自己的镜像

仓库(repository)和仓库注册服务器（registry）是有区别的。仓库注册服务器上往往放着很多个仓库，每个仓库中又包含了很多个镜像，每个镜像有不同的标签（tag）。使用示例：仓库名:TAG号

Docker常用命令

帮助命令

docker version			  # 查看docker版本
docker info				  # 查看详细信息
docker 命令 help			 # 查看docker命令

Docker命令地址：https://docs.docker.com/reference/

镜像命令

  • docker images： 查看本地上所有的镜像信息

    halley@halley-HBL-WX9:~$ docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
centos       latest    5d0da3dc9764   17 months ago   231MB

docker images
-a, --all             Show all images (default hides intermediate images) # 显示所有镜像
      --digests         Show digests
-f, --filter 	filter   Filter output based on conditions provided
      --format 	string   Format output using a custom template:
-q, --quiet           Only show image IDs	# 只显示镜像ID

  • docker search： 搜索镜像

    halley@halley-HBL-WX9:~$ sudo docker search mysql
NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
-f, --filter 	filter   Filter output based on conditions provided	# --filter=STARTS=3000 starts大于3000
      --format 	string   Pretty-print search using a Go template
      --limit 	int       Max number of search results
      --no-trunc        Don't truncate output

  • docker pull： 下载镜像

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

  • docker rmi： 删除镜像

    docker rmi 镜像ID 						# 删除镜像
docker rmi 镜像ID，镜像ID，镜像ID，镜像ID 	  # 删除镜像
docker rmi -f $(docker images ps -aq)	  # 删除所有镜像

容器命令

  • 运行容器docker run

    docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]

    # 新建并进入容器"
docker run --name="Name" -it 镜像名 /bin/bash

# 参数说明
--name="Name"	容器名字
-d				后台方式幸运
-it				使用交互方式运行，进入容器查看内容
-p				制定容器端口		-p 8080:8080
	-p ip:主机端口：容器端口
	-p 主机端口：容器端口
	-p 容器端口
-P				随机指定端口

  • 退出容器

    • 容器停止容器 exit
    • 容器不停止退出 Ctrl+Q+P

  • 列出容器信息

    docker ps		# 列出当前正在运行的容器
	-a			# 列出所有容器
	-n=?		# 显示最近创建的容器
	-q			# 只显示容器的编号

  • 停止容器和启动容器

    • 启动容器 docker start 容器ID
    • 重启容器 docker restart 容器ID
    • 停止容器 docker stop 容器ID
    • 杀死容器 docker kill 容器ID

  • 重新进入容器

    1. docker exec [OPTIONS] CONTAINER COMMAND [ARG...] 

      # docker exec -it 容器id bashShell
halley@halley-HBL-WX9:~$ sudo docker exec -it 28d0bc22ad07 /bin/bash
[root@28d0bc22ad07 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@28d0bc22ad07 /]#

    2. docker attach [OPTIONS] CONTAINER

      # docker attach 容器id

    3. 两者区别

      docker exec：创建一个新的终端

      docker attach：进入当前运行的终端，不会启动新的进程

  • 删除容器

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

其他命令

后台启动容器

docker run -d 镜像名

查看日志命令

dockr logs						# docker logs -tf --tail n 镜像ID
	-f		
	-n		--tail num 			# 显示多少条日志
	-t

查看容器中进程信息命令

docker top 镜像ID
UID          PID         PPID         C        STIME         TTY            TIME            CMD
root        24642        24621        0        14:10        pts/0        00:00:00        /bin/bash

查看容器信息

docker inspect 容器id

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

# docker cp 容器id:容器内路径	目的主机路径

# 查看容器id
halley@halley-HBL-WX9:~$ sudo docker ps -a
CONTAINER ID   IMAGE     COMMAND       CREATED        STATUS                     PORTS     NAMES
28d0bc22ad07   centos    "/bin/bash"   18 hours ago   Exited (0) 4 minutes ago             admiring_bassi
# 进入当前容器
halley@halley-HBL-WX9:~$ sudo docker attach 28d0bc22ad07
[root@28d0bc22ad07 /]# cd home
# 在容器中新建一个文件
[root@28d0bc22ad07 home]# touch test.go  
[root@28d0bc22ad07 home]# ls
test.go
[root@28d0bc22ad07 home]# exit
exit
# 将容器内的文件拷贝到宿主机上
halley@halley-HBL-WX9:~$ sudo docker cp 28d0bc22ad07:/home/test.go /home/halley
Preparing to copy...
Successfully copied 1.536kB to /home/halley
halley@halley-HBL-WX9:~$ ls
Desktop    Downloads    Music     Projects  Repository  Software   test.go	# 
Documents  Environment  Pictures  Public    snap        Templates  Videos

提交镜像

# docker commit -a="NAME" -m="MESSAGE" 容器id 镜像名字：版本
docker commmit 提交容器变成一个新的副本

#命令和git原理类似
docker commit -m="提交信息" -a="作者" 容器id 目标镜像：[TAG]

小结

作业练习

Docker上部署nginx服务器

  1. 搜索镜像 search
  2. 下载镜像 pull
  3. 启动容器 run
# -d 后台运行
# --name 容器名字
# -p 服务器端口
halley@halley-HBL-WX9:~$ sudo docker run -d --name nginx01 -p 4141:80 nginx
b35cdb82dc007051fc53b3219e872d57694e8d18797a1ed652de3118f2d5f401
halley@halley-HBL-WX9:~$ sudo docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                   NAMES
b35cdb82dc00   nginx     "/docker-entrypoint.…"   12 seconds ago   Up 12 seconds   0.0.0.0:4141->80/tcp, :::4141->80/tcp   nginx01
halley@halley-HBL-WX9:~$ curl localhost:4141

# 进入容器
halley@halley-HBL-WX9:~$ sudo docker exec -it nginx01 /bin/bash
root@b35cdb82dc00:/# whereis nginx 
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@b35cdb82dc00:/# cd /etc/nginx
root@b35cdb82dc00:/etc/nginx# ls
conf.d	fastcgi_params	mime.types  modules  nginx.conf  scgi_params  uwsgi_params
root@b35cdb82dc00:/etc/nginx#

Docker设置内存大小

docker run -d --name NAME -p PORT:PORT -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" IMAGES

容器数据卷（基础）

进阶详解请看官网：https://docs.docker.com/storage/volumes/

什么是容器数据卷

容器数据卷其实就是一个容器与宿主机一个同步映射机制

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

使用数据卷

  • 方法一：直接使用命令挂载 -v

    docker run -it -v 主机目录：容器内目录

  • 方法二：使用Dockerfile进行挂载

    FROM centos
VOLUME /data		# 在根目录下创建data目录并设置为挂载点

具名挂载和匿名挂载

  • 具名挂载顾名思义就是挂载的数据卷有名字

    # 方式一：在运行容器时直接指定
docker run -d -v NAME:创建的容器挂载点 --name 镜像名字 镜像 
# 方式二：
docker volume create my-vol
docker run -d \
  --name=nginxtest \
  --mount source=nginx-vol,destination=/usr/share/nginx/html \
  nginx:latest
# 方式三
docker run -d -v 宿主机的挂载数据卷：创建的容器挂载点 --name 镜像名字 镜像

  • 匿名挂载意味着挂载的数据卷没有名字

    docker run -d -v 创建的容器挂载点 --name 镜像名字 镜像

注意：当没指定源地址时默认的挂载地址时在/var/lib/docker/volumes下面

root@halley-HBL-WX9:/home/halley/test# cd /var/lib/docker
root@halley-HBL-WX9:/var/lib/docker# ls
buildkit  containers  engine-id  image  network  overlay2  plugins  runtimes  swarm  tmp  volumes
root@halley-HBL-WX9:/var/lib/docker# cd volumes
root@halley-HBL-WX9:/var/lib/docker/volumes# ls
4bd60d1f4562321a35ee3ea46ca1cf60fd1e9195ff2c27c0243f30e53245e89b  backingFsBlockDev  metadata.db  v_centos
root@halley-HBL-WX9:/var/lib/docker/volumes#

DockerFile

什么是Dockerfile

Dokckerfile相当于一个脚本文件，用来创建Docker镜像，里面包括了创建Docker镜像的命令

Dockerfile格式

# Comment
INSTRUCTION arguments	# 指令 参数

编写简单的Dockerfile

  • Dockerfile

    FROM centos

RUN echo "这个是简单的Dockerfile创建的镜像"

  • 使用build命令构建镜像 docker build -t 镜像名字:版本号 .

    halley@halley-HBL-WX9:~/test$ sudo docker build -t mycentos:1.0 .
[+] Building 0.3s (4/5)                                                         
[+] Building 0.4s (4/5)                                                         
[+] Building 0.5s (4/5)                                                         
 => [internal] load .dockerignore                                          0.1s
[+] Building 0.6s (6/6) FINISHED                                                
 => [internal] load .dockerignore                                          0.1s
 => => transferring context: 2B                                            0.0s
 => [internal] load build definition from Dockerfile                       0.1s  => => transferring dockerfile: 109B                                       0.0s  => [internal] load metadata for docker.io/library/centos:latest           0.0s  => [1/2] FROM docker.io/library/centos                                    0.0s
 => [2/2] RUN echo "这个是简单的Dockerfile创建的镜像"                                 0.4s
 => exporting to image                                                     0.0s
 => => exporting layers                                                    0.0s
 => => writing image sha256:954a522a9cdb46dced490173e4cb1318d409ffe92c171  0.0s
 => => naming to docker.io/library/mycentos:1.0                            0.0s
halley@halley-HBL-WX9:~/test$ sudo docker images
REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
mycentos     1.0       954a522a9cdb   13 seconds ago   231MB		# 新建的Docker镜像
nginx        latest    605c77e624dd   13 months ago    141MB
mysql        latest    3218b38490ce   14 months ago    516MB
centos       latest    5d0da3dc9764   17 months ago    231MB
halley@halley-HBL-WX9:~/test$

    注意：在使用build命令构建docker镜像时，结束必须叫上 ‘.’ ，表示没有参数再输入了，否则会构建出错

Dockerfile常用命令

  • FROM指令

    # 设置构建的镜像的基础镜像
FROM 镜像名

  • MAINTAINER指令（废弃了，推荐使用LABEL指令）

    # 设置镜像作者
MAINTAINER user_name user_email

  • RUN指令

    # 设置在编译镜像时运行的脚本，其编写方式有两种
# shell命令
RUN <command>
# 执行方式
RUN ["executable", "param1", "param2"] (exec form)	# 必须是双引号",而不是单引号‘

# 例如：
RUN /bin/bash -c 'source $HOME/.bashrc && echo $HOME'	# shell命令
RUN ["/bin/bash", "-c", "echo hello"]					# 执行方式

  • CMD指令

    # 设置在容器启动时执行的脚本，当出现多个CMD命令时，只有最后一个CMD命令生效
CMD <shell 命令> 
CMD ["<可执行文件或命令>","<param1>","<param2>",...]  
CMD ["<param1>","<param2>",...]

    注意：CMD指令容器启动默认执行之时，如果如果想要对一个docker指令添加参数时，必须使用完整的指令，CMD无法添加参数，例如

    # Dockerfile
CMD docker ls -a
# shell中

  • 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."
# 格式二
LABEL multi.label1="value1" multi.label2="value2" other="value3"
# 格式三
LABEL multi.label1="value1" \
      multi.label2="value2" \
      other="value3"

  • EXPOSE指令

    # 暴露镜像端口
EXPOSE <port> [<port>/<protocol>...]

    EXPOSE指令默认的是tcp协议，如果需要指定为udp协议，需要指定

    EXPOSE 80/udp

    如果两种协议都需要，则可以都指定

    EXPOSE 80/tcp
EXPOSE 80/udp

    注意：虽然在Dockerfile中指定了镜像端口，但是没有设置镜像端口与宿主机的端口映射，因此如果需要设置端口映射需要在容器启动时，需要手动加入端口映射关系，如

    docker run -p 80:80/tcp -p 80:80/udp ...

  • ENV

    # 设置环境变量
ENV <key>=<value> ...
# ENV指令有两种编写形式
# 第一种
ENV MY_NAME="John Doe"
ENV MY_DOG=Rex\ The\ Dog
ENV MY_CAT=fluffy
# 第一种红还可以用一个ENV指令写
ENV MY_NAME="John Doe" MY_DOG=Rex\ The\ Dog \
    MY_CAT=fluffy
# 第二种	第二种则不可以用一个ENV实现多行书写
ENV MY_VAR my-value

  • ADD

    # 在镜像中添加文件
ADD <src> <dest>
# 添加文件到目录下
ADD test.txt /mydir/			# <dest>加入/表示当前，<dest>是一个目录

# 将文件内容写入 mytest
ADD test.txt /mytest			# <dest>不加/，表示当前<dest>是一个常规文件

# 压缩文件,自动解压
ADD jmeter.log.zip /myzipdir/	

# 添加目录
ADD TeamFile /

# 其他文件
ADD jmeter.log /mydir/

# 多个文件
ADD test1.txt test2.txt /mydir/

# 通配符,dest 不存在自动创建
ADD test*.txt /mydir/test/

# 特殊字符串
ADD add[[]0].txt /mydir/

WORKDIR /data

# 相对路径
ADD test.txt test/				# 等价于 ADD test.txt <WORKDIR>/test/

# ADD指令支持远程拉取文件
ADD [--keep-git-dir=<boolean>] <git ref> <dir>

  • COPY

    COPY指令和ADD指令效果相同，都是将文件拷贝到镜像中，但是前者不支持远程拉取文件，后者支持

    # 拷贝文件 --chown只适合与Linux系统
COPY [--chown=<user>:<group>] <src>... <dest>
COPY [--chown=<user>:<group>] ["<src>",... "<dest>"]

  • ENTRYPOINT

    效果同CMD指令，都是在容器启动的过程中，执行的指令，但是效果有一点不一样，该指令可以在容器启动时添加参数，而CMD不行

    # 执行方式
ENTRYPOINT ["executable", "param1", "param2"]
# shell命令方式
ENTRYPOINT command param1 param2

    CMD和ENTRYPOINT的区别

    1. RUN 在Build Image的时候执行。
    2. CMD ENTRYPOINT 在运行Image时执行。
    3. CMD 可以和ENTRYPOINT 搭配使用，也可以单个命令使用。当CMD 和ENTRYPOINT都出现在一个DockerFile中时，CMD中设置的信息（EXEC格式的）都以参数的形式提供给ENTRYPOINT命令。EntryPoint 命令没有设置时，默认是/bin/bash
    4. ENTRYPOINT的命令不可以简单被覆盖，但可以使用run 中的–entrypoint被覆盖，如果docker run时提供参数，这些参数附加在ENTRYPOINT 里面设置的内容后面。
    5. CMD 单独使用时，如果run 命令后面中提供参数，那么参数会完全覆盖CMD

  • VOLUME

    # 设置镜像的挂载点，源地址缺省默认为/var/lib/volumes
VOLUME ["/data"]	# 形式一
VOLUME /data		# 形式二
# 指定源地址
VOLUME <src> <dest>

    详解请看<容器数据卷>

  • USER

    # 设置当前镜像运行所属的用户ID
USER <user>[:<group>]
# 设置当前镜像运行所属的用户组ID
USER <UID>[:<GID>]

  • WORKDIR

    # 设置工作目录，默认为根目录	/
WORKDIR </工作目录>				# 必须从根目录开始
# 出现多个WORKDIR，则是路径拼接
WORKDIR /a
WORKDIR b
WORKDIR c
RUN pwd							#显示 /a/b/c
# 配合ENV变量使用
ENV DIRPATH=/path
WORKDIR $DIRPATH/$DIRNAME
RUN pwd							# /path/$DIRNAME

  • ARG

    # 定义变量
ARG key=value
# 若ARG指令定义与FROM之前，那么该指令只能作用于FROM指令中

  • ONBUILD

    # ONBUILD指令是当其他镜像以该镜像为基础镜像而触发的指令，其后面跟着其他dockerfile指令，如
ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

练习—编写Dockerfile文件

FROM centos

MAINTAINER halley<ccoder1024@gmail.com>

RUN ["/bin/sh","-c","echo The images is successfully created!"]

LABEL version=1.0 
LABEL description="This is a self-made images which is built on centos"

EXPOSE 10086/tcp
EXPOSE 10086/udp

ENV MY_PATH="/usr/local"

WORKDIR $MY_PATH

ADD test.go $MY_PATH/test/

COPY test.java $MY_PATH/test/

ARG MYPATH=/usr/local/data

VOLUME ["$MYPATH"]

CMD ["/bin/bash"]
  • 基于centos镜像，创建自己镜像

在这里插入图片描述

  • 使用docker inspect mycentos:1.0查看镜像详细信息

    root@halley-HBL-WX9:/home/halley/test# docker inspect mycentos:1.0
[
    {
        "Id": "sha256:4dbf5b511defdc40236cfa1c9b39649c3a0e8644b1bb5b35979a3d6d13d22381",
        "RepoTags": [
            "mycentos:1.0"
        ],
        "RepoDigests": [],
        "Parent": "",
        "Comment": "buildkit.dockerfile.v0",
        "Created": "2023-02-16T13:50:09.73761099+08:00",
        "Container": "",			# 因为没启动容器，所以容器信息没有
        "ContainerConfig": {		# 容器配置
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": null,
            "Cmd": null,
            "Image": "",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": null
        },
        "DockerVersion": "",
        "Author": "halley<ccoder1024@gmail.com>",		# MAINTAINER 维护者信息
        "Config": {										# 镜像配置
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {							# 暴露给宿主机端口，未进行端口映射
                "10086/tcp": {},
                "10086/udp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [									# 环境变量
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",	# centos自带的环境变量配置
                "MY_PATH=/usr/local"					# 自己编写的环境变量
            ],
            "Cmd": [									# 容器启动时触发的指令
                "ls",
                "-l"
            ],
            "ArgsEscaped": true,
            "Image": "",
            "Volumes": {								# 挂载点
                "/usr/local/data": {}
            },
            "WorkingDir": "/usr/local",					# 当前工作目录
            "Entrypoint": [								# 容器启动时触发的指令
                "ls",
                "-a"
            ],
            "OnBuild": null,
            "Labels": {									# LABEL指令 自己编写的 description和version
                "description": "This is a self-made images which is built on centos",
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS",
                "version": "1.0"
            }
        },
	...
]

  • 测试容器启动

    1. 进入mycentos终端后，会直接到工作目录/usr/local下

      root@halley-HBL-WX9:/home/halley/test# docker run -it --rm centos:1.0
[root@5f5e96083eba local]#

    2. 进入mycentos终端后，输入ls，会有data目录

    3. 宿主机/var/lib/docker/volums会出现匿名挂载数据卷

    root@halley-HBL-WX9:/home/halley/test# docker run -it centos:1.0
# 启动容器之后直接到达工作目录，工作目录下有一个data目录
[root@e63b45b276cf local]# ls
bin  data  etc	games  include	lib  lib64  libexec  sbin  share  src  test
[root@e63b45b276cf local]# exit
# 查看容器ID，上面有可以不用docker ps -a查看
root@halley-HBL-WX9:/home/halley/test# docker ps -a
CONTAINER ID   IMAGE        COMMAND       CREATED          STATUS                      PORTS     NAMES
3c08d26d8655   centos       "/bin/bash"   12 minutes ago   Exited (0) 12 minutes ago             youthful_bhabha
e63b45b276cf   centos:1.0   "/bin/bash"   18 minutes ago   Exited (0) 15 minutes ago             optimistic_chaum
# 查看容器信息，会有一个Mounts的键值对，此处就包含了容器挂载数据卷的信息
root@halley-HBL-WX9:/home/halley/test# docker inspect e63b45b276cf
{
	...
	"Mounts": [
            {
                "Type": "volume",
                "Name": "6250eccc5f9e42dea97e263e5b6197d2b749bd5cca7a70b0be4d25fd4a5e96c4",
                "Source": "/var/lib/docker/volumes/6250eccc5f9e42dea97e263e5b6197d2b749bd5cca7a70b0be4d25fd4a5e96c4/_data",
                "Destination": "/usr/local/data",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
	...
}

到此，自己编写的Dockerfile文件就完成了

以上就是Docker基础知识点，基本上可以使用Docker了，但是要非常熟练使用并深入了解Docker，那么以上知识点肯定不够，至少还需要掌握以下知识

  1. Docker网络
  2. Docker Compose
  3. Docker Swarm
  4. 多看官方文档

参考视频：狂神说Docker
参考文献：菜鸟教程Docker
官方地址：Docker官方地址

Docker基础知识入门
weixin_45534397的博客
03-30 957
Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像Docker应用运行在容器中，使用沙箱机制，相互隔离Docker如何解决开发、测试、生产环境有差异的问题？Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统运行时利用沙箱机制形成隔离容器，各个应用互不干扰。
Docker中的Registry和Repository
whatday的专栏
02-08 3075
很多文章中，没有可以区分registery和repostry的关系。事实上，他们俩还是很不一样的。简单来说， Registry：注册服务器，用于管理镜像仓库，起到的是服务器的作用。 Repository：镜像仓库，用于存储具体的docker镜像，起到的是仓库存储作用。 两者的关系可以简单从下图中体现出来。 Registry下的组织关系 由上图可以看出，注册服务器可以管理多个镜像仓库，...
Repository和Registry区别
热门推荐
Lovnx
07-05 1万+
Repository：本身是一个仓库，这个仓库里面可以放具体的镜像，是指具体的某个镜像的仓库，比如Tomcat下面有很多个版本的镜像，它们共同组成了Tomcat的Repository。Registry：镜像的仓库，比如Docker Hub，Registry上有很多的Repository，Redis、Tomcat、MySQL等等Repository组成了Registry。按照Docker的logo来看
docker基础知识
weixin_73735141的博客
03-27 1313
该文章仅介绍了一些关于Docker的基础知识孤儿卷​是 Docker 中未被任何容器关联或使用的数据卷。容器被删除时未使用-v参数同步清理关联卷；手动创建了数据卷但未挂载到容器；容器意外终止或配置错误导致卷未被正确释放。孤儿卷会持续占用宿主机存储空间，若未及时清理可能引发资源浪费。方法一：手动删除单个体积docker volume rm <孤儿卷名称>方法二：批量清理所有未使用卷注：此命令会删除所有未被任何容器或服务引用的孤儿卷，操作前会要求用户确认。
docker 基础知识
weixin_54132204的博客
07-13 1129
docker
Docker基础知识大全
m0_62476845的博客
08-03 1369
正在学习中，以后会不断更新此内容，敬请期待！！！如果文章有问题的话也可以私信我或指出来！！！！！
Docker基础知识总结
TT-Learning
11-20 818
Docker 是一个开源的应用容器引擎，基于 Go 语言开发，遵从Apache2.0开源协议，依赖Linux内核的Cgroup和Namespace等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。目标：Build once，Run anywhere（一次封装，到处运行）
docker基础知识点及使用
wangsir_666的博客
09-22 2475
镜像是蓝图：它的构建是静态的，定义了如何创建容器。容器是实例：它是动态的、可以运行的实例，执行具体的任务，拥有自己的状态和数据。dockerfile构建镜像的步骤
Docker 基础知识
weixin_63566388的博客
07-29 549
什么是 Docker？Docker 的核心组件是什么？Docker 的优点是什么？
Docker基础知识全解析
王华春_Jason
04-28 1737
上面对 Docker 进行了基础知识的全解析。我们了解了 Docker 是什么以及它的核心概念，包括 Docker 镜像、Docker 容器、Dockerfile 和 Docker Compose。我们还介绍了如何使用 Docker 来管理应用程序和构建容器化的应用程序。特别是用这种提问方式来进行分享，我学到了很多，在没有提问之前，总感觉自己好像都会了，但是真正实践的时候发现很多问题还是一窍不通。​。
Docker 基础知识，基础命令等
12-10
Docker是一个开源的应用容器引擎，旨在简化应用程序的打包、分发和运行过程，使其能够...掌握这些基础知识和命令，能够帮助开发者和运维人员更加高效地使用Docker来部署和管理应用程序，提高开发和运行的灵活性和效率。
精选资源
docker-fundamentals:Docker基础知识
04-23
Docker基础知识 Docker基础知识涵盖了哪些内容？ Docker简介 Docker安装 流程1：从Docker Hub拉出并在本地运行Docker Image。 流程2：构建新的Docker映像并在本地运行，然后推送到Docker Hub。 基本Docker命令 ...
docker基础知识之挂载本地目录的方法
09-30
了解并熟练掌握这些 Docker 基础知识，尤其是挂载本地目录和数据卷的使用，对于日常开发和运维工作至关重要，能够有效提高工作效率并保障数据安全。在实际应用中，根据具体需求选择合适的数据交换方法，可以更好地...
CentOS Docker 安装指南
最新发布
csbysj2020的博客
12-20 293
恭喜！您已成功在 CentOS 系统上安装了 Docker。现在，您可以开始使用 Docker 容器化技术来部署和管理应用程序了。希望本指南能帮助您快速上手 Docker。如果您在使用过程中遇到任何问题，请查阅 Docker 官方文档或寻求社区支持。
kubectl 命令行更新项目版本号
March_A的博客
12-18 140
摘要：本文介绍了两种在Kubernetes中更新Deployment镜像版本的方法。第一种是使用kubectl set image命令直接指定新镜像地址，通过--record参数记录变更历史；第二种是登录master节点后使用kubectl edit手动修改Deployment配置。两种方法都会触发滚动更新，可以通过kubectl rollout status实时查看更新进度。文中以demo-app为例，详细说明了容器名与新镜像的对应关系以及命名空间(-n)参数的使用。
【微服务 Day1】SpringCloud实战开发（Mybatis-plus + Docker）
weixin_61639349的博客
12-17 1042
Mybatis-plus + docker保姆级教程
《8076 能通 9003 却超时？一次 Docker 容器跨网段排障小记》
weixin_41544125的博客
12-18 539
8076 通、9003 不通，说明网络链路（Docker 网桥 → 宿主机转发 → 物理交换机）没问题，只看到 SYN，没有 SYN-ACK → 包被目标主机丢弃。宿主机（192.168.100.8）本地执行。都 OK，排除 DNS 与三层路由大问题。RustFS 日志也不再出现。正常，所以服务确定在跑。
Docker 容器（一）
youxiao_90的博客
12-20 892
Docker 是一种容器化技术，它使得开发者可以将应用及其依赖打包到一个标准化的容器中，从而在任何环境下都能一致地运行。传统虚拟化需要在每个虚拟机中运行完整的操作系统，资源消耗大，而 Docker 仅在宿主操作系统上运行多个隔离的容器，不需要完整的操作系统，大大减少了系统开销和资源浪费。注意：如果镜像有多个标签，删除指定标签不会删除镜像本身，只有在没有其他标签和容器依赖的情况下才会彻底删除镜像。是一个开源的容器化平台，能够让开发者将应用及其依赖环境打包成容器，从而简化跨平台的部署和管理。
掌握Docker基础知识：安装、构建与命令详解
标题“Docker-fundamentals:Docker基础知识”指出接下来的内容将会对Docker的基础知识点进行介绍和说明。在IT行业中，Docker作为一种流行的容器化技术，能够帮助开发者打包应用及其依赖包到一个可移植的容器中，然后...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HalleyCoder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值