Docker基础

最新推荐文章于 2025-06-02 09:02:40 发布

原创最新推荐文章于 2025-06-02 09:02:40 发布 · 443 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#docker #运维 #容器

Docker

linux部署形式

vmware虚拟机 + centos（ISO镜像）= 得到一个可以使用的linux系统、
如上大前提，是你得有一个宿主机（你学习使用的电脑，macbook，windows笔记本）

lnmp集群部署

mysql集群部署

zabbix监控系统

。。。。

之前我们都是直接在你安装的linux机器上，进行部署如上软件

安装
修改配置文件
启动
使用各种功能

引出为什么要学习Docker

虚拟机的模板功能，vmware提供了模板克隆

虚拟化技术

将计算的工作，放到云上去执行

去阿里云购买RDS数据库服务，不需要自己搭建数据库，做数据库高可用等等

我对数据的增删改查，用的全都是云上的数据库

虚拟机工具巨头

vmware workstation（属于个人学习使用）
企业版虚拟化 vmware esxi虚拟化工具，高性能服务器结合，进行服务器资源虚拟化

正式学习 Docker

一个公司，它内部所有的应用系统，都是运行在公司内部的虚拟机平台的

有一个平台（网站），这个平台是通过linux技术，OpenStack搭建的，可以非常方便的管理公司的服务器资源，进行快捷的虚拟机创建，删除，扩容，缩容，等等。

vmware – workstation windows 下的图形化工具

创建虚拟机，运行完整的操作系统，用于运行各种应用

Centos1 web nginx
Centos2 db mysql redis
，，，

Docker 的底层原理

Docker 是基于 Google 公司推出的 Golang 语言开发而来，基于 Linux 内核的 Cgroups 、 NameSpace ，以及 Union FS 等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。

Docker 的优势

利用 Docker 可以实现开发，测试，生产环境的部署一致性，极大的减少运维成本。

有无 Docker 的区别

无 Docker ：
在这里插入图片描述

有 Docker ：

在这里插入图片描述

Docker 安装部署

docker 最核心的组件

Images 镜像，构建容器（我们讲应用程序运行所需的环境，打包为镜像文件）
Container，容器（你的应用程序，就跑在容器中）
DockerHub ，镜像仓库（保存镜像文件，提供上传、下载镜像）作用好比github
Dockerfile，将你部署项目的操作，写成部署脚本，且该脚本还能构建出镜像文件

创建容器的过程

获取镜像，如docker pull centos，从镜像仓库拉取
使用镜像创建容器
分配文件系统，挂载一个读写层，在读写层加载镜像
分配网络/网桥接口，创建一个网络接口，让容器和宿主机通信
容器获取 IP 地址
执行容器命令，如 /bin/bash
反馈容器启动结果

安装Docker

提前准备好一个宿主机（ vmware 去创建一个 linux 机器，然后运行 docker 去使用）

基础环境配置

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

yum clean all

yum makecache

yum install -y bash-completion vim lrzsz wget expect net-tools nc nmap tree dos2unix htop iftop iotop unzip telnet sl psmisc nethogs glances bc ntpdate openldap-devel -y

安装 Docker

开启 linux 内核的流量转发

cat <<EOF > /etc/sysctl.d/docker.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.all.rp_filter = 0
net.ipv4.ip_forward = 1
EOF

# 加载修改内核的参数，配置文件
# 按照如下命令，执行顺序
modprobe br_netfilter
sysctl -p /etc/sysctl.d/docker.conf

利用yum快速安装 docker

# 提前配置好 yum 仓库
# 1.阿里云自带仓库 2.阿里云提供 docker 专属 repo 仓库
curl -o /etc/yum.repos.d/Centos-7.repo http://mirrors.aliyun.com/repo/Centos-7.repo

curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.re
po

# 更新 yum 缓存
yum clean all && yum makecache

# 可以直接 yum 安装 docker 了

## yum 安装
yum install docker-ce-20.10.6 -y
## 查看源中可用版本
yum list docker-ce --showduplicates | sort -r
## 如果要安装旧版本
yum install docker-ce-18.09.9 -y

## 卸载 docker
yum remove -y docker-xxx

尝试启动，使用 docker

配置 Docker 加速器

用于加速镜像文件的下载

mkdir -p /etc/docker
touch /etc/docker/daemon.json
vim /etc/docker/daemon.json
cat /etc/docker/daemon.json
{
    "registry-mirrors": [
        "https://dockerproxy.com",
        "https://hub-mirror.c.163.com",
        "https://mirror.baidubce.com",
        "https://ccr.ccs.tencentyun.com"
    ]
}

启动 Docker

[root@Response ~]# systemctl daemon-reload
[root@Response ~]# systemctl enable docker
[root@Response ~]# systemctl restart docker

# 查看 Docker 是否启动成功
root@Response:/home/ubuntu01# docker version
Client:
 Version:           20.10.25
 API version:       1.41
 Go version:        go1.18.1
 Git commit:        20.10.25-0ubuntu1~22.04.1
 Built:             Fri Jul 14 21:58:09 2023
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server:
 Engine:
  Version:          20.10.25
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.18.1
  Git commit:       20.10.25-0ubuntu1~22.04.1
  Built:            Thu Jun 29 21:21:05 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.7.2
  GitCommit:
 runc:
  Version:          1.1.7-0ubuntu1~22.04.1
  GitCommit:
 docker-init:
  Version:          0.19.0
  GitCommit:

启动第一个 Docker 容器

# 1.获取镜像
# 2.运行镜像，生成容器，你想要的程序，就允许在容器中

#

nginx web 服务器，运行一个80端口的网站

在宿主机上，运行nginx

开启服务器
在服务器上安装好运行nginx所需的依赖关系
安装 nginx yum install nginx -y
修改nginx配置文件
启动nginx
客户端去访问nginx

比较耗时。。。

如果让你使用 docker 运行 nginx，该怎么玩

# 1. 获取镜像，获取是从你配置好的 docker 镜像站中， 去拉取 nginx 镜像
# 先搜索一下，镜像文件是否存在
docker search nginx
# 拉取下载镜像
docker pull xxx
# 查看本地镜像
docker images
# 删除镜像
docker rmi [INAGE ID]

# 拉取nginx
root@Response:/etc/docker# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
186b1aaa4aa6: Pull complete
b4df32aa5a72: Pull complete
a0bcbecc962e: Pull complete
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

# 再次查看 nginx
root@Response:/etc/docker# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    9c7a54a9a43c   3 months ago    13.3kB
nginx         latest    605c77e624dd   19 months ago   141MB

# 运行该nginx镜像，运行出具体的镜像，然后在这个容器中，就跑着一个nginx服务
docker run [参数] [镜像的名字/id]

# 参数解释 -d 后台运行容器
# 参数解释 -p 80:80		-p 端口映射， 宿主机端口 : 容器内端口， 你访问了宿主机的端口，也就访问到了容器内端口
root@Response:/etc/docker# docker run -d -p 80:80 nginx
1fe2322f86583b3aab40f4838e8c2f6680f7a1264d5a0828987addb4e64270d9

# 查看容器是否在运行
root@Response:/etc/docker# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                               NAMES
1fe2322f8658   nginx     "/docker-entrypoint.…"   2 minutes ago   Up 2 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp   blissful_chandrasekhar

# 此时就可以使用宿主机的80端口访问容器内的 nginx

# 可以尝试停止容器，看下结果
docker stop 容器id

Docker 生命周期

学习 docker 的核心要素、搞明白、镜像、容器！

在这里插入图片描述

彻底学明白， docker 镜像的原理

我们再获取 redis 镜像的时候，发现是下载了多行信息，最终又得到完整的镜像文件

root@Response:/etc/docker# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
a2abf6c4d29d: Already exists
c7a4e4382001: Pull complete
4044b9ba67c9: Pull complete
c8388a79482f: Pull complete
413c8bb60be2: Pull complete
1abfd3011519: Pull complete
Digest: sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest
root@Response:/etc/docker# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    9c7a54a9a43c   3 months ago    13.3kB
nginx         latest    605c77e624dd   19 months ago   141MB
redis         latest    7614ae9453d1   20 months ago   113MB
root@Response:/etc/docker#

来看一看 Docker 的镜像原理

我们用的 CentOS7 系统长什么样

我们一直以来，使用vmware虚拟机，安装的系统，是一个完整的系统，是一个完整的系统文件，包括2部分

linux 内核，作用是提供操作系统的基础功能，和机器硬件交互
centos7发行版，作用是提供软件功能，例如 yum 安装包管理等

因此， linux 内核 + centos 发行版，就组成了一个系统，让我们用户使用。

是否有一个办法，可以灵活的替换发行版，让我们使用不同的【系统】？

那么 docker 就实现了这个功能，技术手段就是 docker images

查看系统信息

# 发行版本
cat /etc/redhat-release
# 内核
uname -r

在这里插入图片描述

快速实践，使用 docker ，来切换不同的发行版，内核使用的都是宿主机的内核

# 利用 docker 获取不同的发行版镜像
# 获取 centos
docker pull centos:7.8.2003
# 获取 ubuntu
docker pull ubuntu

#确认当前的宿主机发行版
root@Response:/# cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=22.04
DISTRIB_CODENAME=jammy
DISTRIB_DESCRIPTION="Ubuntu 22.04.2 LTS"
root@Response:/#

# 运行centos7.8.2003发行版
# 运行容器，且进入容器内
# 参数解释： -i 交互式命令操作 -t 开启一个终端 afb6fca791e0 镜像id bash 进入容器后执行的命令
root@Response:/# docker run -it afb6fca791e0 bash
[root@d96d5bf94c76 /]# 

# 查看容器内的centos发行版本
[root@d96d5bf94c76 /]# cat /etc/redhat-release
CentOS Linux release 7.8.2003 (Core)

# 使用ubuntu
root@Response:/# docker run -it ba6acccedd29 bash
root@cce309ab0e75:/#

# 查看容器内的ubuntu发行版本
root@cce309ab0e75:/# cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.04
DISTRIB_CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04.3 LTS"

# 使用suse
root@Response:/# docker run -it d9e50bf28896 bash
cfa96daa23f4:/ #

# 查看容器内的suse发行版本
cfa96daa23f4:/ # cat /etc/SuSE-release
openSUSE 42.3 (x86_64)
VERSION = 42.3
CODENAME = Malachite
# /etc/SuSE-release is deprecated and will be removed in the future, use /etc/os-release instead

# 退出容器空间
exit

小结

一个完整的系统，是由linux的内核 + 发行版，才组成了一个可以使用的完整的系统
利用 docker 容器，可以获取不同的发行版镜像，然后基于该镜像，运行出各种容器去使用

Docker 具体解决了什么问题

在这里插入图片描述

理解什么是 Docker 镜像

docker images 搜索地址

https://hub.docker.com/_/centos?tab=tags&page=1&ordering-last_updated

1、一个完整的 docker 镜像可以创建出docker容器的运行，例如一个 centos7.8.2003 镜像文件，我们获取的是 centos7 这个发行版，这个镜像文件是不包含linux内核的

root@Response:/# docker images
REPOSITORY    TAG        IMAGE ID       CREATED         SIZE
hello-world   latest     9c7a54a9a43c   3 months ago    13.3kB
nginx         latest     605c77e624dd   19 months ago   141MB
redis         latest     7614ae9453d1   20 months ago   113MB
ubuntu        latest     ba6acccedd29   22 months ago   72.8MB
centos        7.8.2003   afb6fca791e0   3 years ago     203MB
opensuse      latest     d9e50bf28896   4 years ago     111MB

docker 的架构，镜像就是一个【发行版】的作用，你需要准备好一个 linux 内核，然后上层使用不同的【发行版】就好了，这样你可以自由的使用各种版本系统，兼容多种环境。

在这里插入图片描述

Union File System

docker 通过联合文件系统，将上述的不同的每一层，整合为一个文件系统，为用户隐藏了多层的视角。

小节：

当通过一个 image 启动容器时， docker 会在该 image 最顶层，添加一个读写文件系统作为容器，然后运行该容器。
docker 镜像本质是基于 UnionFS 管理的分层文件系统
docker 镜像为什么才几百兆？

答：因为 docker 镜像只有 rootfs 和其他镜像层，共用宿主机的 liux 内核( bootfs ),因此很小！

为什么下载一个 docker 的 nginx 镜像，需要133MB? nginx 安装包不是才几兆吗？

答：因为 docker 的 nginx 镜像是分层的， nginx 安装包的确就几M,但是一个用于运行 nginx 的镜像文件，依赖于父镜像（上一层)，和基础镜像（发行版），所以下载的 nginx 镜像有一百多兆

Docker 镜像原理学习2

# 进入到正在运行的容器内，命令为 docker exec
root@Response:/# docker exec -it 01424e8862ce bash
root@01424e8862ce:/#

Docker 镜像定义

我们如果自定义镜像， docker 镜像不包含 linux 内核，和宿主机公用。

我们如果想要定义一个 mysql5.7 镜像，我们会怎么做

获取基础镜像，选择一个发行版平台（ubuntu，centos）
在 centos 镜像中安装 mysql5.7 软件

导出镜像，可以命名为 mysql:5.7 镜像文件。

从这个过程，我们可以感觉出这是一层一层的添加的， docker 镜像的层级概念就出来了，底层是 centos 镜像，上层是 mysql 镜像，centos 镜像属于父镜像。

在这里插入图片描述

Docker 镜像是在基础镜像之后，然后安装软件，配置软件，添加新的层，构建出来。

这种现象在学习 dockerfile 构建时候，更为清晰。

Docker 为什么分层镜像

镜像分层一大好处就是共享资源，例如有多个镜像都来自同一个base镜像，那么在 docker host 只需要存储一份 base 镜像。

内存里也只需要加载有一份 host ，即可为多个容器服务。

即使多个容器共享一个 base 镜像，某个容器修改了 base 镜像的内容，例如修改 /etc下配置文件，其他容器的/etc下的内容是不会被修改的，修改的动作只限制在单个容器内，这就是容器的写入时复制特性（Copy-on-write）。

可写的容器层

当容器启动后，一个新的可写层被加载到镜像的顶部，这一层通常被称为 容器层 ，容器层 下的都称为镜像层。

在这里插入图片描述

所有对容器的修改动作，都只会发生在 容器层 里，只有 容器层 是可写的，其余的 镜像层 都是只读的。

文件操作	说明
添加文件	在容器中创建文件时，新文件被添加到容器层中。
读取文件	在容器中读取某个文件时， Docker 会`从上往下`依次在各层镜像层中查找此文件，一旦找到，立即将其复制到容器层，然后打开并读入内存。
修改文件	在容器中修改已存在的文件时， Docker 会`从上往下` 依次在各镜像层中查找此文件。一旦找到，立即将其复制到容器层，然后将容器层中的文件进行修改。
删除文件	在容器中删除文件时， Docker 也是`从上往下` 依次在镜像层中查找此文件，找到后，会在容器层中记录下此删除操作（只是记录删除操作）

只有当需要修改时才复制一份数据，这种特性被称为 Cope-on-Write 。可见，容器层保存的是镜像层变化的部分，不会对镜像本身进行任何修改。

这样就解释了我们前面提出的问题：容器层记录对镜像的修改，所有镜像都是只读的，不会被容器修改，所以镜像可以被多个容器共享。

Docker 镜像的内容

docker 镜像层级管理的方式大大便捷了 Docker 镜像的分发与存储。Docker hub 是为全世界服务的镜像仓库。

Docker 镜像代表一个容器的文件系统内容
镜像层技术属于 联合文件系统
容器是一个动态的环境，每一层镜像里的文件都是静态内容
- dockerfile 里的 ENV 、VOLUME 、CMD 等内容回落实到容器环境里

UnionFS

在这里插入图片描述

Docker 镜像的实际使用

在开发中，会安装很多第三方的工具，比如 etcd , kafka 等等。

不想搞乱当前机器的环境，还想安装 nginx

下载安装 Docker 工具
获取该软件的 Docker 镜像（你以后想要用的各种工具，基本上都能够搜索到合适的镜像去用）
运行该镜像，然后就启动了一个容器，这个 nginx 服务就运行在容器中。
停止容器，删除该镜像，你的电脑上，好像就没使用过 nginx 一样

类似沙箱一样的环境。

获取镜像

从 dockerhub 获取镜像
本地镜像导入、导出
私有的 docker 仓库

# 1. 获取镜像，镜像托管仓库，好比 yum 源一样，
# 默认的 docker 仓库是， dockerhub ，里面有大量优质的镜像，以及用户自己上传的镜像, centos 容器 安装 vim nginx ... 提交为镜像，上传到 dockerhub

docker search 镜像名:tag	# tag 就是具体的标签版本

# 查看本地的镜像文件有哪些
docker images
docker image ls

# 下载 docker 镜像
docker pull centos # 默认是 centos:latest
docker pull centos:7.8.2003

# 查看 docker 镜像的存储路径
docker info
docker info | grep Root

# 存放 docker 镜像的具体，目录
/var/lib/docker/image/overlay2/imagedb/content/sha256

# 该文件作用是 记录 镜像 和容器的配置关系

# 使用不同的镜像，生成容器

# -it 开启一个交互式的终端 --rm 容器退出时删除该容器
root@Response:/# docker run -it --rm centos

# 如何查看 centos 的标签信息
https://hub.docker.com/_/centos

查看镜像

# 查看基础镜像
root@Response:/# docker images
REPOSITORY    TAG        IMAGE ID       CREATED         SIZE
hello-world   latest     9c7a54a9a43c   3 months ago    13.3kB
nginx         latest     605c77e624dd   19 months ago   141MB
redis         latest     7614ae9453d1   20 months ago   113MB
ubuntu        latest     ba6acccedd29   22 months ago   72.8MB
centos        7.8.2003   afb6fca791e0   3 years ago     203MB
opensuse      latest     d9e50bf28896   4 years ago     111MB

# 查看具体的镜像
root@Response:/# docker images centos
REPOSITORY   TAG        IMAGE ID       CREATED       SIZE
centos       7.8.2003   afb6fca791e0   3 years ago   203MB
root@Response:/# docker images ubuntu
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
ubuntu       latest    ba6acccedd29   22 months ago   72.8MB

# 可以指定具体 tag
root@Response:/# docker images centos:7.8.2003
REPOSITORY   TAG        IMAGE ID       CREATED       SIZE
centos       7.8.2003   afb6fca791e0   3 years ago   203MB

# 只列出镜像的 id
-q --quiet # 只列出 id

root@Response:/# docker images -q
9c7a54a9a43c
605c77e624dd
7614ae9453d1
ba6acccedd29
afb6fca791e0
d9e50bf28896

# 格式化显示镜像
# 这是 Docker 的模板语言 --format
root@Response:/# docker images --format "{{.ID}}--{{.Repository}}"
9c7a54a9a43c--hello-world
605c77e624dd--nginx
7614ae9453d1--redis
ba6acccedd29--ubuntu
afb6fca791e0--centos
d9e50bf28896--opensuse

# 以表格形式显示，美化
root@Response:/# docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"
IMAGE ID       REPOSITORY    TAG
9c7a54a9a43c   hello-world   latest
605c77e624dd   nginx         latest
7614ae9453d1   redis         latest
ba6acccedd29   ubuntu        latest
afb6fca791e0   centos        7.8.2003
d9e50bf28896   opensuse      latest

# 搜索 dockerhub 里的镜像
docker search 镜像名

root@Response:/# docker search java
NAME                               DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
node                               Node.js is a JavaScript-based platform for s…   12831     [OK]
tomcat                             Apache Tomcat is an open source implementati…   3574      [OK]
java                               DEPRECATED; use "openjdk" (or other JDK impl…   1994      [OK]
ghost                              Ghost is a free and open source blogging pla…   1646      [OK]
couchdb                            CouchDB is a database that uses JSON for doc…   530       [OK]
jetty                              Jetty provides a Web server and javax.servle…   402       [OK]
amazoncorretto                     Corretto is a no-cost, production-ready dist…   322       [OK]
groovy                             Apache Groovy is a multi-faceted language fo…   142       [OK]
ibmjava                            Official IBM® SDK, Java™ Technology Edition …   120       [OK]
tomee                              Apache TomEE is an all-Apache Java EE certif…   109       [OK]
bitnami/java                       Bitnami Java Docker Image                       21                   [OK]
javanile/vtiger                    Vtiger CRM is open source software that help…   14                   [OK]
appdynamics/java-agent             Java Agent for Kubernetes                       10
javanile/novnc                     Ready to use NoVNC client for SeleniumHQ on …   3                    [OK]
circleci/java                      This image is for internal use                  2
kasmweb/java-dev                   Ubuntu Java development desktop for Kasm Wor…   1
circleci/java-nginx                Java+nginx image. This image is for internal…   1
javanile/adminer                   Build adminer                                   1                    [OK]
airbyte/java-datadog-tracer-base   Docker image that provides the DataDog Java …   0
javanile/vtiger-dev                Ready for development vtiger docker image       0
javanile/bash-ci                                                                   0
javanile/xdebug                                                                    0
javanile/make.bat                                                                  0
javanile/pwd                                                                       0
javanile/mysql                     MySQL for development                           0

# 查看镜像运行情况
docker ps
# 查看镜像运行列表
docker ps -a

删除镜像

# 根据镜像的 id 、名字 、摘要等
# 被删除的镜像，不能有依赖的容器记录
docker rmi 镜像名字
docker rmi id前三位

# 删除容器记录
docker rm 容器id

镜像管理

# 取出命令的执行结果
echo `docker images -aq` 

# 批量删除镜像的用法

## 删除所有镜像，慎用
docker rmi `docker images -aq`

## 删除所有容器
docker rm `docker ps -aq`

# 导出镜像
## 比如默认运行的 centos 镜像，不提供 vim 功能， 运行该容器后， 在容器内安装 vim
## 然后提交该镜像，再导出该镜像为压缩文件，可以发给其他人使用

# 导出镜像的命令
root@Response:/opt# docker image save centos:7.8.2003 > /opt/centos7.8.2003.tgz
root@Response:/opt# ls
centos7.8.2003.tgz  containerd  node-v16.14.2-linux-x64


# 导入镜像的命令
root@Response:/# docker image load -i /opt/centos7.8.2003.tgz
fb82b029bea0: Loading layer [==================================================>]  211.1MB/211.1MB
Loaded image: centos:7.8.2003

# 查看镜像详细信息
docker info # 查看 docker 服务信息

docker image inspect 镜像id/镜像id前三位

容器管理

docker run 等于创建 + 启动

docker run 镜像名，如果镜像在本地不存在，则会在线去下载该镜像

注意：容器内进程必须处于前台运行状态，否则容器将会直接退出，自己部署一个容器运行，命令不得后台运行，前台运行即可

如果容器内什么事也没做，容器也会挂掉，容器内必须有一个进程在前台运行

我们运行 nginx 基础镜像，没有运行任何程序，因此容器直接挂掉

# 运行镜像的玩法

# 1. 运行一个挂掉的容器，（从错误示范来学 docker 容器）
docker run centos:7.8.2003
# 这个写法，会产生多条独立的容器记录，且容器内没有程序运行，挂了

root@Response:/# docker images
REPOSITORY   TAG        IMAGE ID       CREATED         SIZE
nginx        latest     605c77e624dd   19 months ago   141MB
redis        latest     7614ae9453d1   20 months ago   113MB
ubuntu       latest     ba6acccedd29   22 months ago   72.8MB
centos       7.8.2003   afb6fca791e0   3 years ago     203MB
opensuse     latest     d9e50bf28896   4 years ago     111MB
root@Response:/# docker run centos:7.8.2003
root@Response:/# docker run centos:7.8.2003
root@Response:/# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
root@Response:/# docker ps -a
CONTAINER ID   IMAGE             COMMAND       CREATED              STATUS                          PORTS     NAMES
a11eaf2fb220   centos:7.8.2003   "/bin/bash"   5 seconds ago        Exited (0) 5 seconds ago                  agitated_newton
5fc91a0a8e48   centos:7.8.2003   "/bin/bash"   8 seconds ago        Exited (0) 7 seconds ago                  zealous_euclid
ee6f3fdef6a3   centos:7.8.2003   "/bin/bash"   26 seconds ago       Exited (0) 25 seconds ago                 sweet_rosalind
ca266dd3ea6f   centos:7.8.2003   "/bin/bash"   27 seconds ago       Exited (0) 27 seconds ago                 cranky_wiles
2ce61be33a1a   centos:7.8.2003   "/bin/bash"   About a minute ago   Exited (0) About a minute ago             compassionate_mclean
root@Response:/#

# 2. 运行容器，且进入容器内，且在容器内执行某个命令
root@Response:/# docker run -it centos:7.8.2003 bash
[root@e3ca278ea945 /]# cat /etc/redhat-release
CentOS Linux release 7.8.2003 (Core)
[root@e3ca278ea945 /]#

# 开启一个容器，让它帮你运行某一个程序，属于前台运行，会卡着一个终端
root@Response:/# docker run centos:7.8.2003 ping baidu.com
PING baidu.com (39.156.66.10) 56(84) bytes of data.
64 bytes from 39.156.66.10 (39.156.66.10): icmp_seq=1 ttl=47 time=23.3 ms
64 bytes from 39.156.66.10 (39.156.66.10): icmp_seq=2 ttl=47 time=22.2 ms
64 bytes from 39.156.66.10 (39.156.66.10): icmp_seq=3 ttl=47 time=21.0 ms

# 4. 运行一个活着的容器
# -d 参数，让容器在后台跑着（针对宿主机而言）
# 返回容器id
root@Response:/# docker run -d centos:7.8.2003 ping baidu.com
30e8b39367ef5d8c3012327f5fc766360738321e7163d0efe85efc0808fb0e9e

# 5. 丰富 docker 运行参数
# -d 后台运行
# --rm 容器挂掉后，自动删除记录
# --name 给容器起个名字
root@Response:/# docker run -d --rm --name co-blog centos:7.8.2003 ping 39.101.72.168
acefda83213bcb1201913366476904a237bf010bfeb4c17562fde77a9e0a70ad
root@Response:/# docker ps
CONTAINER ID   IMAGE             COMMAND                CREATED         STATUS         PORTS     NAMES
acefda83213b   centos:7.8.2003   "ping 39.101.72.168"   3 seconds ago   Up 2 seconds             co-blog
root@Response:/#

# 6. 查看容器日志的玩法
docker logs 容器id
## 实时刷新日志
docker logs -f 容器id

## 查看最新的x条日志
docker logs 容器id | tail -x

# 7. 进入正在运行的容器空间内
## exec指令用于进入容器空间内
docker exec -it 容器id bash

# 8. 查看容器的详细信息，用于高级调试
docker container inspect 容器id

# 9. 容器的端口映射
## 后台运行 nginx 容器，且起个名字，且端口映射宿主机的 85 端口，访问到容器内的80端口
root@Response:/# docker run -d --name co_blog_nginx -p 85:80 nginx
16b2c75ff2c147083a7e9b8e80782cd623cd8f9d051c74a6cab2f864fa17e008

## 查看容器
root@Response:/# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED              STATUS              PORTS                               NAMES
16b2c75ff2c1   nginx     "/docker-entrypoint.…"   About a minute ago   Up About a minute   0.0.0.0:85->80/tcp, :::85->80/tcp   co_blog_nginx

# 9.1 查看容器内的端口情况
docker port 容器id

root@Response:/# docker port 16b2c75ff2c1
80/tcp -> 0.0.0.0:85
80/tcp -> :::85

# 9.2 随机端口映射
-p 随机访问一个宿主机的空闲端口，映射到容器内打开的端口
docker run -P 镜像id

# 10. 容器的提交
## 运行基础的 centos:7.8.2003，在容器内安装 vim，然后提交新的镜像
## 新的镜像，在运行出的容器，默认就携带 vim 了

## 运行容器
docker run -it centos:7.8.2003 bash

# 提交容器
docker commit 容器id 新的镜像名

容器的端口映射

在这里插入图片描述

DockerFile

镜像是多层存储，内一层在前一层的基础上进行修改；

容器也是多层存储，已镜像为基础层，在其基础上加一层作为容器运行时的存储层。

创建镜像的两种方法

手动修改容器内容，然后 docker commit 提交容器为新的镜像
通过在 dockerfile 中定义一系列的命令和参数构成的脚本，然后这些命令应用于基础镜像，依次添加层，最终生成一个新的镜像。极大的简化了部署工作。

官方提供的 dockerfile 实例

https://github.com/CentOS/CentOS-Dockerfiles

vmware 和 docker 对比，安装 mysql 为例

vmware :

开启 vmware
运行某一个虚拟机， CentOS7
CentOS7 安装 mysql yum install mysql-server
通过脚本，或者命令，启动 mysql 即可

部署缓慢，且修改了宿主机的环境，删除较为麻烦，占用宿主机的一个 3306 端口

docker :

开启 vmware
运行虚拟机 CentOS7 （宿主机）
安装 docker 容器软件
获取 mysql 镜像即可 docker pull mysql:tag （你无法自由控制，该 mysql 的基础镜像是什么发行版，你获取的镜像，是别人定制好的，你下载使用的， debian ，你希望得到一个基于 CentOS7.8 的发行版，运行mysql）
直接运行该镜像，通过端口映射，运行mysql， docker run mysql:5.6（容器能够运行，必须在容器内，有一个进程在前台运行，该容器内，有 mysql 正在前台运行）
访问宿主机的一个映射端口，访问到容器内的 mysql

想要自定义镜像，就需要自己写脚本，也就是 dockerfile

dockerfile 主要组成部分：

基础镜像信息 FROM centos：6.8

制作镜像操作指令 RUN yum install openssh-server -y

容器启动时执行指令 CMD [“/bin/bash”]

dockerfile 指令

FROM # 这个镜像的妈妈是谁？(指基础镜像)

MAINTAINER # 告诉别人，谁负责养它？（指维护者信息，可以没有）

RUN # 你想让它干啥？（在命令前面加上 RUN 即可）

ADD # 添加宿主机的文件到容器内，会自动解压

# RUN tar -zxf /opt/xx.tgz # 报错！该 tgz 文件不存在！！

COPY # 作用和 ADD 是一样的，都是拷贝宿主机的文件到容器内，仅拷贝

WORKDIR # 我是 cd ，今天刚化了妆（指当前工作目录）

VOLUME # 给它一个存放行李的地方（设置卷，挂载主机目录）

EXPOSE # 它要打开的门是啥（指定对外的端口），在容器内暴露一个窗口，端口 EXPOSE 80

CMD # 奔跑吧，兄弟！（指定容器启动后要干的事）

################################## dockerfile 其他指令 ###################################################

COPY # 复制文件

ENV # 环境变量

ENTRYPOINT # 容器启动后执行的命令

# 还有很多

VOLUME 文件目录映射解释：

在这里插入图片描述

快速入门 dockerfile

写一个 dockerfile 构建一个 nginx 镜像，可以运行 nginx 服务

# 通过 dockerfile , 构建 nginx 镜像，且运行容器后，生成的页面，是"The First Docker Project !"
# 1. 创建 Dockerfile ,注意文件名，必须是这个。

FROM nginx
RUN echo '<meta chartset=utf8> The First Docker Project !' > /usr/share/nginx/html/index.html

# 2. 构建 dockerfile
docker build .

# 3. 修改镜像名
docker tag 镜像id 自定义名称

# 构建的镜像如下
REPOSITORY                          TAG        IMAGE ID       CREATED              SIZE
my_nginx                            latest     f7a4cb761b55   About a minute ago   141MB

# 4. 运行该镜像
docker run -d -p 80:80 my_nginx

# 5. 查看宿主机的 80 端口

http://172.27.93.180/

The First Docker Project !

Dockerfile文件具体编写方法

Copy

# copy 指令从宿主机复制文件/目录到新的一层镜像内
# 如
copy test.py /home/

# 支持多个文件，以及通配符形式复制，语法要满足 Golang 的 filepath.Match
copy test* /tmp/cc?.txt. /home/

# COPY 指令能够保留源文件的元数据，如权限，访问时间等等，这点很重要！

ADD

# 特性和 COPY 基本一致，不过多了些功能
# 1. 源文件是一个URL，此时 docker 引擎会下载该链接，放到目标路径，且权限自动设为 600 ，若这不是期望结果，还需要添加一层 RUN 指令进行调整
# 2. 源文件是一个URL，且是个压缩包，不会自动解压，也需要单独用RUN指令解压
# 3. 源文件是一个压缩文件，且是 gzip, bzip2, xz, tar 情况，ADD指令会自动解压该文件到目标路径

CMD

# 用法，注意是双引号
CDM ["参数1","参数2"]

# 默认
CMD ["/bin/bash"]

# 在指定了 entrypoint 指令后，用 CMD 指定具体参数

# docker 不是虚拟机，容器就是一个进程，那么程序在启动的时候需要指定运行参数，这是 CMD 指令作用

# 例如 CentOS 镜像默认的 CMD 是 /bin/bash, 直接 docker run -it centos 会直接进入 bash 解释器。
# 也可以启动容器的时候，指定参数，docker run -it centos cat /etc/os-release


# CMD 运行 shell 命令，也会被转化为 shell 形式
# 例如
CMD echo $PATH
# 会被转化为
CMD ["sh","-c","echo $PATH"]

容器内运行程序

这里注意的是， docker 不是虚拟机的概念，虚拟机里的程序运行，基本上都是在后台运行，利用 systemctl 运行，但是容器内没有后台进程的概念，必须在前台运行。

容器就是为了主进程而存在的，主进程如果退出了，容器也就失去了意义，自动退出。

例如有一个经典的问题

CMD systemctl start nginx
# 这样的写法是错误的，容器会直接退出。

# 因为 systemctl start nginx 是希望以守护进程形式启动 nginx ，且CMD命令会转化为

CMD ["sh","-c","systemctl start nginx"]
# 这样的命令主进程是解释器，执行完毕后立即结束了，因此容器也就退出了。

# 因此正确的做法应该是
CMD ["nginx","-g","daemon off;"]

ENTRYPOINT

和 RUN 指令一样，分为两种形式

exec
shell

作用和 CMD 一样，都是在指定容器启动应用程序以及参数。

当指定了 ENTRYPOINT 之后， CMD 指令的语义就有了变化，而是把 CMD 的内容当作参数传递给 ENTRYPOINT 指令。

实际用法

1、准备好 dockerfile

FROM centos:7.8.2003
RUN rpm --rebuilddb && yum install epel-release -y
RUN rpm --rebuilddb && yum install curl -y
CMD ["curl","-s","http://ipinfo.io/ip"]

2、构建镜像

docker build -t myip .

# 看到如下结果，则表明构建成功
Successfully built 058ca97363f1
Successfully tagged myip:latest

3、检查镜像

root@Response:/home/ubuntu01/learn_docker# docker images
REPOSITORY                          TAG        IMAGE ID       CREATED             SIZE
myip                                latest     058ca97363f1   42 seconds ago      653MB

4、运行镜像

# 生成容器，没有前台运行程序，直接挂了
root@Response:/home/ubuntu01/learn_docker# docker run myip
223.96.95.199root@Response:/home/ubuntu01/learn_docker#

5、上述运行正确，但是我想再传入一个参数，该怎么办

root@Response:/# docker run myip -I
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-I": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled

# 解决办法1
# 给容器传入一个新的，完整的命令
# 方法不合适
root@Response:/home/ubuntu01/learn_docker# docker run centos_curl curl -s http://ipinfo.io/ip -I
HTTP/1.1 200 OK
access-control-allow-origin: *
content-type: text/html; charset=utf-8
content-length: 13
date: Fri, 18 Aug 2023 00:28:23 GMT
x-envoy-upstream-service-time: 1
strict-transport-security: max-age=2592000; includeSubDomains
Via: 1.1 google

6、正确的姿势应该是使用 ENTRYPOINT

# 修改 dockerfile ,如下

FROM centos:7.8.2003
RUN rpm --rebuilddb && yum install epel-release -y
RUN rpm --rebuilddb && yum install curl -y
ENTRYPOINT ["curl","-s","http://ipinfo.io/ip"]

# 重新构建镜像
root@Response:/home/ubuntu01/learn_docker# docker build .

# 重新运行该镜像，看结果，以及传入新的参数
root@Response:/home/ubuntu01/learn_docker# docker run centos_curl_new

# 此时发现，传入的 CMD 命令，当作了 ENTRYPOINT 的参数
# 其实容器内执行的完整命令为 curl -s http://ipinfo.io/ip -I
223.96.95.199root@Response:/home/ubuntu01/learn_docker# docker run centos_curl_new -I
HTTP/1.1 200 OK
access-control-allow-origin: *
content-type: text/html; charset=utf-8
content-length: 13
date: Fri, 18 Aug 2023 00:21:25 GMT
x-envoy-upstream-service-time: 0
strict-transport-security: max-age=2592000; includeSubDomains
Via: 1.1 google

ARG 和 ENV 指令

设置环境变量

# dockerfile 脚本，shell 脚本

ENV NAME = "admin"
ENV AGE = "18"
ENV MYSQL_VERSION = 5.6

# 后续所有的操作，通过 $NAME 就可以直接获取变量值操作了，维护 dockerfile 脚本时更友好，方便

# ARG 和 ENV 一样，设置环境变量
# 区别在于 ENV 无论是在镜像构建时，还是容器运行时，，该环境变量都可以使用
# ARG 只是用于构建镜像需要设置的变量，容器运行时就消失了

VOLUME

容器在运行时，应该保证在存储层不写入任何数据，运行在容器内产生的数据，我们推荐是挂载，写入到宿主机上，进行维护。

# mount /mnt # linux挂载操作

VOLUME /data # 将容器内的 /data 文件夹，在容器运行时，该目录自动挂载为匿名卷，任何向该目录中写入数据的操作，对不会被容器记录，保证了容器存储层无状态理念。

# Dockerfile1
FROM centos:7.8.2003
MAINTAINER Undefined6608
VOLUME ["/data1","/data2"]

# 该容器运行时，这两个目录自动和宿主机的目录做好映射关系
> Dockerfile # 重定向写入文件
docker build .

# 运行该镜像
docker run 镜像id

# 查看生成的容器信息
root@Response:/home/ubuntu01/learn_docker# docker ps -a |head -2
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS                      PORTS     NAMES
89fc8d562340   f8266fd38062      "/bin/bash"              48 seconds ago   Exited (0) 48 seconds ago             trusting_brattain

# docker inspect 命令查看
docker inspect 89fc8d562340

容器数据挂载的方式：

通过 dockerfile，指定 VOLUME 目录
通过 docker run -v 参数，直接设置需要映射挂载的目录

EXPOSE

指定容器运行时对外提供的端口服务

帮助使用该镜像的人，快速理解该容器的一个端口业务

docker port 容器
docker run -p 宿主机端口 : 容器端口
docker run -P # 作用是随机宿主机端口 : 容器内端口

WORKDIR

用于在 dockerfile 中，目录的切换，更改工作目录

WORKDIR /opt

USER

用于改变环境，用于切换用户

USER root
USER Undefined6608

构建一个网站镜像

nginx ,修改首页内容， html 网站就跑起来了，web server ，提供 web 服务，提供代理转发，提供网关，限流等。。apache
web framework , web 框架，一般由开发，通过某个开发语言，基于某个 web 框架，自己去开发一个 web 站点， python，djanggo框架

用 python 语言，基于 flask web 框架，开发一个自己的网站，写了一个后端代码
开发 dockerfile，部署该代码，生成镜像
其他人基于该镜像， docker run 就可以在电脑上跑起来这个网站

http://172.27.93.180:8080/hello

1、在宿主机上准备好一个目录，准备好Dockerfile代码

写一个 flask 的 python 代码

创建代码文件

touch Dockerfile

touch flask_python.py

vim flask_python.py

vim Dockerfile

编辑 flask_python.py

#coding:utf8
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello() :
        return "hello from docker , i am Undefined6608 ."
if __name__ == "__main__":
        app.run(host= '0.0.0.0' , port = 8080)

2、编写 Dockerfile

FROM centos:7.8.2003
RUN curl -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo;
Run curl -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo;
RUN yum makecache fast;
RUN yum install python3-devel python3-pip -y
RUN pip3 install -i https://pypi.douban.com/simple flask
COPY flask_python.py /opt
WORKDIR /opt
EXPOSE 8080
CMD ["python3","flask_python.py"]

3、检查代码环境和内容

4、构建镜像

docker build --no-cache -t 'undefined6608/my_flask_web' . 

# 最后的结果类似如下，则构建完成、
Successfully built ad6181e04739
Successfully tagged undefined6608/my_flask_web:latest

5、运行镜像，生成容器

root@Response:/home/ubuntu01/learn_docker# docker images
REPOSITORY                          TAG        IMAGE ID       CREATED         SIZE
undefined6608/my_flask_web          latest     ad6181e04739   7 seconds ago   733MB
<none>                              <none>     f8266fd38062   2 hours ago     203MB
centos_curl                         latest     92c2480b1ac4   2 hours ago     654MB
centos_curl_new                     latest     b4eeff5923bc   3 hours ago     654MB
undefined6608/centos-vim-7.8.2003   latest     b19d1284e11d   45 hours ago    477MB
nginx                               latest     605c77e624dd   19 months ago   141MB
redis                               latest     7614ae9453d1   20 months ago   113MB
ubuntu                              latest     ba6acccedd29   22 months ago   72.8MB
centos                              7.8.2003   afb6fca791e0   3 years ago     203MB
root@Response:/home/ubuntu01/learn_docker# docker run -d -p 8080:8080 undefined6608/my_flask_web
13ee74c1581848ec760ab927fe223cac192f0fea25fbbc64f1488962f23db228

# 查看运行的容器
root@Response:/home/ubuntu01/learn_docker# docker ps
CONTAINER ID   IMAGE                        COMMAND                  CREATED          STATUS          PORTS                                       NAMES
13ee74c15818   undefined6608/my_flask_web   "python3 flask_pytho…"   31 seconds ago   Up 30 seconds   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   happy_euler

6、查看项目运行情况

http://172.27.93.180:8080/hello

截图：

在这里插入图片描述

8、查看日志

root@Response:/home/ubuntu01/learn_docker# docker logs 13ee74c15818
 * Serving Flask app 'flask_python' (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on all addresses.
   WARNING: This is a development server. Do not use it in a production deployment.
 * Running on http://172.17.0.2:8080/ (Press CTRL+C to quit)
172.27.80.1 - - [18/Aug/2023 02:59:10] "GET /hello HTTP/1.1" 200 -
172.27.80.1 - - [18/Aug/2023 02:59:10] "GET /favicon.ico HTTP/1.1" 404 -

如何修改容器内的应用的内容

Mtd1、修改宿主机的代码，以及 Dockerfile，重新构建

Mtd2、进入到已经运行的容器中，修改代码，重新运行容器即可

# 1. 进入容器
root@Response:/home/ubuntu01/learn_docker# docker exec -it 13ee74c15818 bash
[root@13ee74c15818 opt]#

# 2. 修改容器内的程序
#coding:utf8
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello() :
        return "hello from docker , i am Undefined6608 , This is my first Docker Project !"
if __name__ == "__main__":
        app.run(host= '0.0.0.0' , port = 8080
        
# 退出容器，重启容器
root@Response:/home/ubuntu01/learn_docker# docker restart 13ee74c15818
13ee74c15818
root@Response:/home/ubuntu01/learn_docker# docker ps
CONTAINER ID   IMAGE                        COMMAND                  CREATED          STATUS         PORTS                                       NAMES
13ee74c15818   undefined6608/my_flask_web   "python3 flask_pytho…"   18 minutes ago   Up 4 seconds   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   happy_euler

再次复习 docker 的好处，用法

比如安装一个 etcd、nacos，都是比较复杂的一些软件

需要依赖于 go 语言环境，比如需要依赖于 java 环境，在自己的机器上安装好对应的开发环境，以及对应的版本，以及各种依赖。。

tomcat，jdk环境

当你有了 docker ：

docker pull tomcat # 这些主流的镜像都可以直接找到，并且该镜像中，就已经打包好了 java 环境

docker pull nacos # 打包好了各种依赖环境

docker run tomcat xxx... # 直接就可以访问 tomcat 了

Docker 容器总结

Docker 容器

容器是 Docker 的核心概念，容器是一个或者一组应用，它的运行状态如下：

docker 利用容器运行应用程序
容器的镜像的运行实例，可以被 run 、start 、stop 、rm
每个容器都是相互隔离，保证平台安全
容器可以看作是一个简易版的 Linux 系统（有 root 权限，进程，用户空间，网络）
镜像是只读的，容器在启动的时候创建一层可写层。

在这里插入图片描述

dockerfile 面向开发，docker images 作为交付标准，docker container 涉及部署与运维，三者合起来完成 docker 体系。

上图可以理解

FFROM ubuntu:14.04 # 选择基础镜像
ADD run.sh # 添加文件进镜像，这一层镜像只有一个内容，就是这个文件
VOLUME /data # 设定存储目录，并未添加文件，只是更新镜像里的 json 文件，便于启动时候读取该层信息
CMD ["./run.sh"] # 更新 json 文件，设定程序入口

容器操作

启动容器方式：

基于镜像创建

root@Response:/# docker run ubuntu /bin/echo 'Hello world'

# 启动交互容器
root@Response:/# docker run -it centos:7.8.2003 bash
[root@5346f781d414 /]#
[root@5346f781d414 /]# pwd
/
[root@5346f781d414 /]#
[root@5346f781d414 /]# whoami
root

docker run 镜像id
# 这是前台运行容器

docker run 启动容器的时候， docker 后台操作流程为

检查本地是否有该容器
利用镜像创建且启动一个容器
分配容器文件系统，在只读的镜像层挂载读写层
宿主机的网桥接口会分配一个虚拟接口到容器中
容器获得地址池里的 ip 地址
执行用户指定的程序
若程序里没有进程在运行，容器执行完毕后立即终止

docker start # 可以启动一个处于 stop 状态的容器。

后台运行程序

# 启动后台容器
# 注意端口使用，数字选择大一点的，以免和系统预留冲突
root@Response:/# docker run --name nginx -d --restart=always -p 7070:80 nginx
a4639e39cbdf817e0a09da22774ba6badcbb42d39b316fda7ce842d699193359
root@Response:/#

查看容器内日志

# -f 实时刷新日志
docker logs -f 容器id

查看容器记录

docker ps # 正在运行的容器

docker container ls # 正在运行的容器

docker pa -a # 挂掉以及活着的容器

docker container ls -a # 挂掉以及活着的容器

启动/停止容器

# 启动
docker start 容器id
# 停止
docker stop 容器id

进入容器

# -it 前台交互式
docker exec -it 容器id/容器id前三位 bash

导入/导出/容器快照

# 导出镜像到本地，位置为所在目录下
docker export 容器名 > 导出名.tar

删除容器/镜像

# 删除容器
docker rm 容器id
docker rm `docker ps -aq`
# 强制删除容器
docker rm -f 容器id
docker rm -f `docker ps -aq`

# 删除镜像
docker rmi 镜像id/镜像名

查看容器进程资源信息

docker top 容器id

查看容器内资源信息

docker stats 容器id

查看容器的具体信息

docker inspect 容器id

获取容器内的ip地址，容器的格式化参数

root@Response:/# docker inspect a4639e39cbdf |grep 172
            "Gateway": "172.17.0.1",
            "IPAddress": "172.17.0.2",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
root@Response:/#

docker inspect --format '{{.NetwworkSettings.IPAddreess}}' 容器id