Python3 - 深入学习Docker容器管理

文章目录


在这里插入图片描述

学习目标:

本篇博文意在学习Docker原理, 深入理解docker容器管理, 镜像管理, 学会自定义镜像Dockerfile, 以及部署项目全流程, 灵活掌握Dockerfile关键字; 目标人群适合有一定的Python基础和Linux基础的人群。

篇幅较长, 大约需要10分钟, 实践大约需要4h, 大家根据自己的需要来学习~

声明: 本篇博文为作者原创, 未经作者允许请勿转载!

在这里插入图片描述

一、Docker简介

1.1 为什么选择docker?

1.1.1 docker更高效的利用系统资源

容器不需要进行硬件虚拟化以及进行一个完整操作系统的额外开销, docker对系统资源的利用率更高, 无论是应用执行, 文件存储, 还是在内存消耗等方面, 都比传统的虚拟机更高效。因为一个同样配置的主机, 可以运行处更多数量的容器实例。

1.1.2 更快的启动时间

传统的虚拟机启动时间长, docker容器则是直接运行在宿主机的内核上, 无需启动一个完整的操作系统, 因此可以达到秒级启动, 大大解决开发, 测试, 部署的时间。

在这里插入图片描述

1.1.3 持续交付和部署

对于开发和运维人员, 最关心的环境部署迁移别处的问题, 利用docker可以定制镜像, 以达到持续集成, 持续交付和部署。通过Dockerfile来进行镜像构建, 系统集成测试, 运维进行环境部署。且Dockerfile可以使镜像构建透明化, 方便技术团队快速理解运行环境部署的流程。

1.1.4 更轻松的迁移

Docker可以在很多平台上运行, 无论是物理机, 虚拟机, 云服务器等环境, 运行结果都是一致的。用于可以轻松将一个平台的应用, 迁移到另外一个平台, 而不用担心环境的变化, 导致程序无法运行。

1.2 Docker能做什么?

在这里插入图片描述

  • 可以把应用程序及运行依赖环境打包成镜像, 作为交付介质, 在各环境中部署
  • 可以将镜像(image)启动成为容器(container), 并且提供多容器的生命周期进行管理(启、停、删)
  • container容器之间相互隔离, 且每个容器可以设置资源限额
  • 提供轻量级虚拟化功能, 容器就是在宿主机中的一个个虚拟的空间, 彼此相互隔离, 完全独立

1.3 Docker最核心的组件

在这里插入图片描述

  • image镜像, 构建容器 (我们将程序运行所需的环境, 打包为镜像文件)

  • Container, 容器 (你的应用程序, 就跑在容器中)

  • 镜像仓库 (保存镜像文件, 提供上传, 下载镜像) 作用好比github

  • Dockerfile, 将你部署项目的操作,写成一个部署脚本, 这就是dockerfile, 且该脚本还能构建出镜像文件

    • FROM 定义基础镜像
    • MAINTAINER 作者
    • RUN 运行Linux命令
    • ADD 添加文件/目录
    • ENV 环境变量
    • CMD 运行进程

    创建容器的过程

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

二、Docker安装部署

提前准备好一个宿主机(VMware去创建一个linux机器, 然后安装docker去使用)

2.1 基础环境配置

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

2.2 安装docker

2.2.1 docker必须安装在centos7平台, 内核不低于3.10

uname -r # 3.10.0-1160.59.1.el7.x86_64

sudo yum -y upgrade  # 更新yum源

2.2.2 开启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

2.2.3 重新加载内核参数

modprobe br_netfilter # 如果下面的命令报错, 先执行此条命令
sysctl -p /etc/sysctl.d/docker.conf

要保持本地软件源较新, 可以用阿里云yum源更新软件

2.2.4 安装docker-ce社区版

利用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.repo

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

## 查看源中可用版本
sudo yum list docker-ce --showduplicates | sort -r

## 如果需要安装旧版本
sudo yum install -y docker-ce-18.09.9

## yum 安装
sudo yum install docker-ce-20.10.6 -y

## 查看docker版本
rpm -qa | grep docker

## 如果要卸载
sudo yum remove docker-xxxx-centos.x86_64
 
[harry@iZ8vbbip4bxxx60rxxuZ ~]$ rpm -qa | grep docker
docker-scan-plugin-0.17.0-3.el7.x86_64
docker-ce-cli-20.10.14-3.el7.x86_64
docker-ce-20.10.6-3.el7.x86_64
docker-ce-rootless-extras-20.10.14-3.el7.x86_64

## 尝试启动docker

2.2.5 镜像加速器

使用docker受邀操作就是获取镜像文件, 默认下载是从Docker Hub下载, 网速很慢, 国内很多云服务商都提供了加速器服务, 阿里云加速器, Daocloud加速器, 灵雀云加速器等。

### 检查是否有这个文件, 没有就创建一个
### vim /etc/docker/daemon.json
### 写入
{
  "registry-mirrors": [
    "https://8xpk5wnt.mirror.aliyuncs.com"
  ]
}

### 启动docker
systemctl daemon-reload
systemctl enable docker
systemctl restart docker

### 查看docker是否正确安装

[harry@iZ8xxx4bq97z0o60rq3uZ ~]$ sudo docker version
[sudo] password for harry: 
Client: Docker Engine - Community
 Version:           20.10.14
 API version:       1.41
 Go version:        go1.16.15
 Git commit:        a224086
 Built:             Thu Mar 24 01:49:57 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.6
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.13.15
  Git commit:       8728dd2
  Built:            Fri Apr  9 22:43:57 2021
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.5.11
  GitCommit:        3df54a852345ae127d1fa3092b95168e4a88e2f8
 runc:
  Version:          1.0.3
  GitCommit:        v1.0.3-0-gf46b6ba
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0
[harry@iZ8vbbipxxx0o60rq3uZ ~]$ 

三、启动第一个docker容器

3.1 docker流程示意图

在这里插入图片描述

# 1.获取镜像
# 2.运行镜像, 生成容器, 你想要的容器, 就运行在容器中

以往需求: Nginx web服务器, 运行出一个80端口的网站

# 在宿主机上, 运行nginx
1.开启服务器
2.在服务器上安装好运行nginx所需的依赖关系
3.安装nginx yum install nginx -y
4.修改nginx配置文件
5.启动nginx
6.客户端去访问nginx

比较耗时~~

如果让你用docker运行nginx, 该怎么玩?

3.2 Docker运行nginx

1.获取镜像, 获取是从你配置好的docker镜像中, 去拉取nginx镜像
# 先搜索一下, 镜像文件, 是否存在
docker search nginx
# 拉取, 下载镜像
docker pull nginx
# 查看本地的docker镜像都有哪些
[harry@iZ8vbbxxxz0o60rq3uZ ~]$ sudo docker image ls -a
REPOSITORY       TAG         IMAGE ID       CREATED        SIZE
jupyter-centos   1.0         2aeba7cbf80d   2 days ago     658MB
star7th/showdoc  latest      e06fda0e7caa   9 days ago     589MB
nginx            latest      605c77e624dd   2 months ago   141MB

# 删除镜像的命令
sudo docker rmi 镜像id

# 运行该nginx镜像, 运行出具体的容器, 然后这个容器中就跑着一个nginx服务了
# 运行镜像的命令, 参数如下
docker run 参数   镜像的名字/id

# -d 后台运行容器
# -p 80:80 端口映射, 宿主机端口:容器内端口, 访问宿主机端口也就访问到容器内的端口
sudo docker run -d -p 80:80 nginx

# 查看端口
 netstat -tunlp

# 运行结果如下, docker run命令, 会返回一个容器id
[harry@iZ8vbbxxx60rq3uZ ~]$ sudo docker run -d -p 80:80 nginx
c526cbb32432532be79218480fba837a0e88a2e9756de510fa19b10e3236500f

# 此时可以访问宿主机的80端口, 查看到容器内的80端口的应用是什么了
# 查看正在运行的容器
sudo docker ps

[harry@iZ8vbbip4bq97z0o60rq3uZ ~]$ sudo docker ps
CONTAINER ID   IMAGE    COMMAND     CREATED      STATUS   PORTS          NAMES
c526cbb32432   nginx   "/dock"   18 seconds ago   Up 12 seconds 80/tcp, 0.0.0.0:80->80/tcp, :::80->80/tcp    mystifying_ganguly

# 可以尝试停止容器
sudo docker stop 容器id
# 停止具体的容器进程
sudo docker stop c526cbb32432

[harry@iZ8vbbixxx7z0o60rq3uZ ~]$ sudo docker stop c526cbb32432
c526cbb32432

# [harry@iZ8vxxxz0o60rq3uZ ~]$ sudo docker start 3599e7f5d321
3599e7f5d321

3.3 端口映射示意图

在这里插入图片描述

四、docker生命周期

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

在这里插入图片描述

4.1 详细图解:

在这里插入图片描述

五、彻底学明白, docker镜像的原理

5.1 分层拉取镜像

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

[harry@iZ8vbbip4bq97z0o60rq3uZ ~]$ sudo 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

5.2 利用docker获取不同发行版镜像

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

# 查看系统的两大部分 宿主机Centos内核+上层发行版
[harry@iZ8vbxxxx60rq3uZ ~]$ cat /etc/redhat-release 
CentOS Linux release 7.9.2009 (Core)
[harry@iZ8vxxx7z0o60rq3uZ ~]$ 
[harry@iZ8vxxx4z0o60rq3uZ ~]$ uname -r
3.10.0-1160.59.1.el7.x86_64
# 利用docker获取不同发行版镜像
docker pull centos:7.8.2003

docker pull ubuntu

# 确认当前的宿主机发行版
[harry@iZ8xxx7z0o60rq3uZ ~]$ cat /etc/redhat-release 
CentOS Linux release 7.9.2009 (Core)

# 运行centos7.8.2003发行版
# 运行容器, 且进入容器内
# 参数 解释 
# -i 交互式命令操作 
# -t 开启一个终端 
# afb6fca791e0 镜像的id
# bash bash解释器
[harry@iZ8vbbip4bq97z0o60rq3uZ ~]$ docker run -it afb6fca791e0 bash
root@0o60rq3uZ: /#
root@0o60rq3uZ: /# cat /etc/redhat-release 
CentOS Linux release 7.8.2003 (Core)

# 想玩玩Ubuntu
# 直接去获取Ubuntu镜像即可
[harry@iZ8vbbxxx0o60rq3uZ ~]$ sudo docker run -it ubuntu bash
root@wqdf24s1e212131: /#
root@wqdf24s1e212131: /#
# 查看容器内的发行版
root@wqdf24s1e212131: /# cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.4
DISTRIB.CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04.2 LTS"

图解以上操作:

在这里插入图片描述

总结:

1.一个完整的系统, 是由linux的内容+发行版, 才组成了一个可以使用的完整的系统

2.利用docker容器, 可以获取不同的发型版镜像, 然后基于该镜像, 运行出各种容器去使用

5.3 docker具体解决了什么问题

一个工程师, 写代码, mysql, etcd, redis, elk 等等…在机器上, 直接安装了这些工具, win mac

在这里插入图片描述

5.4 理解什么是docker镜像

docker images搜索地址: https://hub.docker.com/_/centos?tab=tags&page=1&ordering=last_updated

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

[harry@iZ8xxxz0o60rq3uZ ~]$ sudo docker images
REPOSITORY     TAG       IMAGE ID       CREATED        SIZE
nginx          latest    605c77e624dd   3 months ago   141MB
redis          latest    7614ae9453d1   3 months ago   113MB
centos         7         eeb6ee3f44bd   6 months ago   204MB

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

5.5 Docker 镜像的原理学习(一)

在这里插入图片描述

图解注释:

在这里插入图片描述

5.6 Docker 镜像原理学习(二)

# 进入到正在运行的容器内(nginx), 命令是 docker exec
[harry@iZ8vbbixxxx0o60rq3uZ ~]$ sudo docker exec -it 3599e7f5d321 bash
root@3599e7f5d321:/# 

root@3599e7f5d321:/# cat /etc/os-release  
PRETTY_NAME="Debian GNU/Linux 11 (bullseye)"
NAME="Debian GNU/Linux"
VERSION_ID="11"
VERSION="11 (bullseye)"
VERSION_CODENAME=bullseye
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"
root@3599e7f5d321:/# 

在这里插入图片描述

5.7 Docker为什么分层镜像

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

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

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

5.8 可写的容器层

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

在这里插入图片描述

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

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

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

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

六、Docker镜像的实际使用学习

日常开发中, 需要安装很多第三方工具, 比如etcd, kafka等

开发机器: mac, windows, 我又不想搞乱当前机器的环境

mac装一个nginx, 二进制安装, 编译安装, brew install nginx…

1.下载安装docker工具

2.获取该软件的docker镜像(你以后想要用的各种工具, 基本上都能够搜索到合适的镜像去用)

nginx镜像docker pull nginx

3.运行该镜像, 然后就启动了一个容器, 这个nginx服务就运行在容器中

4.停止容器, 删除该镜像, ok, 你的电脑上, 就好像没有使用过nginx一样

类似沙箱一样的环境

基于镜像的增、删、改、查维护

6.1 获取镜像

6.1.1 从dockerhub获取镜像

6.1.2 本地镜像导出、导入

6.1.3 从私有部署获取镜像

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

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

docker search centos

# 查看本地的镜像文件有哪些
[harry@iZ8vbbbq97z0o60rq3uZ ~]$ sudo docker images
[harry@iZ8vbbbq97z0o60rq3uZ ~]$ sudo docker image ls

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

# 查看docker镜像的存储路径
Docker Root Dir: /var/lib/docker

[harry@iZ7z0o60rq3uZ ~]$ sudo ls /var/lib/docker/image/overlay2/imagedb/content/sha256/ -l
total 44
-rw------- 1 root root  7656 Mar 29 20:40 605c77e624ddb75e6110f997c58876baa13f8754486b461117934b24a9dc3a85
-rw------- 1 root root  7700 Mar 29 21:34 7614ae9453d1d87e740a2056257a6de7135c84037c367e1fffa92ae922784631
-rw------- 1 root root 23304 Mar 23 14:51 e06fda0e7caa83f226f077d7f2b6a419c1a03e91af31ee7fe23a6482534fe146
-rw------- 1 root root  2754 Mar 27 19:10 eeb6ee3f44bd0b5103bb561b4c16bcb82328cfe5809ab675bb17ab3a16c517c9

[harry@iZ8vo60rq3uZ ~]$ sudo cat /var/lib/docker/image/overlay2/imagedb/content/sha256/605c77e624ddb75e6110f997c58876baa13f8754486b461117934b24a9dc3a85

# 该文件作用是
记录 镜像 和 容器 的配置关系
# 使用不同的镜像, 生成容器
# -it 开启一个交互式的终端 --rm 容器退出时删除该容器
[harry@iZ897z0o60rq3uZ ~]$ sudo docker run -it --rm centos:7.8.2003 bash

[root@dc1ef93a01be /]# cat /etc/redhat-release 
CentOS Linux release 7.8.2003 (Core)

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

6.2 查看镜像

[harry@iZ8vbq97z0o60rq3uZ ~]$ sudo docker images
REPOSITORY    TAG        IMAGE ID       CREATED         SIZE
star7th/showdoc  latest  e06fda0e7caa   9 days ago      589MB
nginx         latest     605c77e624dd   3 months ago    141MB
redis         latest     7614ae9453d1   3 months ago    113MB
centos        7          eeb6ee3f44bd   6 months ago    204MB
centos        7.8.2003   afb6fca791e0   23 months ago   203MB

# 查看具体的镜像
[harry@iZ97z0o60rq3uZ ~]$ sudo docker images nginx
[sudo] password for harry: 
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    605c77e624dd   3 months ago   141MB

# 可以指定具体tag
[harry@iZ8v0o60rq3uZ ~]$ sudo docker images centos:7.8.2003
REPOSITORY   TAG        IMAGE ID       CREATED         SIZE
centos       7.8.2003   afb6fca791e0   23 months ago   203MB

# 只列出镜像的id
-q --quiet  # 只列出id
[harry@iZ8v60rq3uZ ~]$ sudo docker images -q
e06fda0e7caa
e06fda0e7caa
605c77e624dd
7614ae9453d1
eeb6ee3f44bd
afb6fca791e0

# 格式化显示镜像
# 这是docker的模板语言,  --format
[harry@iZ8bq90rq3uZ ~]$ sudo docker images --format "{{.ID}}--{{.Repository}}"
e06fda0e7caa--star7th/showdoc
e06fda0e7caa--registry.cn-shenzhen.aliyuncs.com/star7th/showdoc
605c77e624dd--nginx
7614ae9453d1--redis
eeb6ee3f44bd--centos
afb6fca791e0--centos

# 以表格形式显示, 美化
sudo docker images --format "table{{.ID}}\t{{.Repository}}\t{{.Tag}}"
[harry@iZ8v60rq3uZ ~]$ sudo docker images --format "table{{.ID}}\t{{.Repository}}\t{{.Tag}}"
IMAGE ID       REPOSITORY                                          TAG
e06fda0e7caa   star7th/showdoc                                     latest
e06fda0e7caa   registry.cn-shenzhen.aliyuncs.com/star7th/showdoc   latest
605c77e624dd   nginx                                               latest
7614ae9453d1   redis                                               latest
eeb6ee3f44bd   centos                                              7
afb6fca791e0   centos                                              7.8.2003

# 搜索镜像
# docker search 镜像名
[harry@iZ87z0o60rq3uZ ~]$ sudo docker search centos
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
centos                            The official build of CentOS.                   7082      [OK]       
centos/systemd                    systemd enabled base container.                 107                  [OK]
centos/mysql-57-centos7           MySQL 5.7 SQL database server                   92            

6.3 删除镜像

[harry@iZ8vbbip4bq60rq3uZ ~]$ curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io
docker version >= 1.12
{
  "registry-mirrors": ["http://f1361db2.m.daocloud.io"]
}
Success.
You need to restart docker to take effect: sudo systemctl restart docker 

[harry@iZ8vbbo60rq3uZ ~]$ sudo systemctl restart docker 

# 下载
docker pull hello-world

# 根据镜像的 id, 名字, 摘要
docker rmi hello-world
[harry@iZ8vb97z0o60rq3uZ ~]$ sudo docker rmi hello-world
Untagged: hello-world:latest
Untagged: hello-world@sha256:bfea6278a0a267fad2634554f4f0c6f31981eea41c553fdf5a83e95a41d40c38
Deleted: sha256:feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412
Deleted: sha256:e07ee1baac5fae6a26f30cabfe54a36d3402f96afda318fe0a96cec4ca393359

# Error response from daemon: conflict: unable to remove repository reference "hello-world" (must force) - container e2970e766c01 is using its referenced image feb5d9fea6a5
如果出现这个错误, 则先执行下面的命令

# 删除容器记录
docker rm 容器id
[harry@iZ8vb7z0o60rq3uZ ~]$ sudo docker rm e2970e766c01

# 指定id的前三位即可
docker rmi d11

6.4 镜像管理

[harry@iZ8vbb0o60rq3uZ ~]$ sudo docker images -aq
e06fda0e7caa
e06fda0e7caa
605c77e624dd
7614ae9453d1
eeb6ee3f44bd
afb6fca791e0

# 批量删除镜像的用法, rm
# 批量删除镜像, 慎用
sudo docker rmi `docker images -aq`

# 批量删除容器
sudo docker rm `docker ps -aq`

# 导出镜像
# 比如默认运行的centos镜像, 不提供vim功能, 运行该容器后, 在容器内安装vim
# 然后提交该镜像, 再导出该镜像为压缩文件, 可以发给其他人用
# 放在容器管理篇学习
docker commit

# 导出镜像的命令
[root@iZ8vbb0rq3uZ ~]$ sudo docker image save centos:7.8.2003 > /opt/centos7.8.2003.tgz

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

# 查看镜像详细信息
# 查看docker服务的信息
docker info
# 查看镜像详细信息
docker image inspect 镜像id
docker image inspect afb

七、Docker容器管理

docker run 等于创建+启动

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

**注意: 容器内的进程必须处于前台运行, 否则容器就会直接退出,**自己部署一个容器运行, 命令不得后台运行, 前台运行即可

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

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

# 运行容器的玩法
# 1.运行一个挂掉的容器 (从错误师范来学docker容器)
docker run centos:7.8.2003
这个写法, 会产生多个独立的容器记录, 且容器内没有程序在跑, 因此挂了
[harry@iZ8vz0o60rq3uZ ~]$ sudo docker run afb6fca791e0
[harry@iZ8vz0o60rq3uZ ~]$  sudo docker run afb6fca791e0
[harry@iZ8vz0o60rq3uZ ~]$  sudo docker run afb6fca791e0
[harry@iZ8vz0o60rq3uZ ~]$  sudo docker ps -a
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS                      PORTS                                                      NAMES
40003a3f5c7e   afb6fca791e0      "/bin/bash"              14 seconds ago   Exited (0) 10 seconds ago                                                              sleepy_moore
e7f13b99ff15   afb6fca791e0      "/bin/bash"              21 seconds ago   Exited (0) 16 seconds ago                                                              happy_newton
7a618ef8376d   afb6fca791e0      "/bin/bash"              29 seconds ago   Exited (0) 24 seconds ago                                                              practical_torvalds

# 2.运行容器, 且进入容器内, 且在容器内执行某个命令
[harry@iZ8vbbip4b0rq3uZ ~]$ sudo docker run -it centos:7.8.2003 sh
sh-4.2# 
sh-4.2# 

# 3.开启一个容器, 让它帮你运行某个程序, 属于前台运行, 会卡住一个终端
[harry@iZ8vbbi3uZ ~]$ sudo docker run centos:7.8.2003 ping baidu.com
64 bytes from 220.181.38.251 (220.181.38.251): icmp_seq=1 ttl=52 time=7.81 ms
64 bytes from 220.181.38.251 (220.181.38.251): icmp_seq=2 ttl=52 time=7.76 ms

# 4.运行一个活着的容器, docker ps 可以看到的容器
# -d 参数, 让容器在后台跑着 (针对宿主机而言)
# 返回容器id
[harry@iZ8vbbio60rq3uZ ~]$ sudo docker run -d centos:7.8.2003 ping baidu.com
e346320e4740b47025dd97bc7c511a02f23480429114d048935af08199798c02

# 5.丰富docker运行的参数
# -d 后台运行
# --rm 容器挂掉后自动被删除
# --name 给容器起个名字

[harry@iZ8vb0rq3uZ ~]$ sudo docker run -d --rm --name pythontest centos:7.8.2003 ping baidu.com
bdd9e13fd341f0c548260dfbfd90fb7cd32e3bd0b532952faccd0da7c839e9d9
[harry@iZ8vb0oq3uZ ~]$ sudo docker ps
CONTAINER ID   IMAGE           COMMAND     CREATED  STATUS          PORTS       NAMES
bdd9e13fd341  centos:7.8.2003 "ping baidu.com" 18   seconds ago  Up 15 seconds  pythontest

# 6.查看容器日志的玩法, 刷新日志
# -f 实时刷新日志
[harry@iZ8o60rq3uZ ~]$ sudo docker logs 容器id
[harry@iZ8o60rq3uZ ~]$ sudo docker logs -f 容器id
[harry@iZ8o60rq3uZ ~]$ sudo docker logs -f 容器id | tail -5

# 7.进入正在运行的容器空间内
# exec指令用于进入容器空间内
[harry@iZ8vbbz0o60rq3uZ ~]$ sudo docker exec -it 64d2af1f679e bash
[root@64d2af1f679e /]# 

# 8.查看容器的详细信息, 用于高级调试
[harry@iZ8vbbi0o60rq3uZ ~]$ sudo docker container inspect 容器id

# 9.容器的端口映射
# 后台运行nginx容器, 且起个名字, 且端口映射宿主机的777端口, 访问到容器内的80端口
[harry@iZ8v0rq3uZ ~]$ sudo docker run -d --name harry_nginx -p 777:80 nginx
# 查看容器
[harry@iZ0o60rq3uZ ~]$ sudo docker ps
CONTAINER ID   IMAGE  COMMAND              CREATED        STATUS          PORTS        NAMES
73d306b1b3bf   nginx "/docker-entrypoint.…"48 seconds ago Up 41 seconds  0.0.0.0:777->80/tcp, :::777->80/tcp   harry_nginx

# 9.1 查看容器的端口转发情况
docker port 容器id
[harry@iZ8v0o60rq3uZ ~]$ sudo docker port 73d306b1b3bf
80/tcp -> 0.0.0.0:777
80/tcp -> :::777

# 随机端口映射 -P 随机访问一个宿主机的空闲端口, 映射到容器内打开的端口
[harry@iZ8v0rq3uZ ~]$ sudo docker run -d --name harry_nginx -P nginx

# 10.容器的提交
# 运行基础的centos:7.8.2003, 在容器内安装vim, 然后提交新的镜像
# 新的镜像, 再运行出的容器, 默认就携带vim了
[harry@iZ8vbbip4o60rq3uZ ~]$ sudo docker run -it centos:7.8.2003 bash
[root@17773e3413fc /]# yum install vim

# 提交容器
docker commit 容器id 新的镜像名
[harry@iZ8vo60rq3uZ ~]$ sudo docker commit 17773e3413fc harry88995/centos-vim-7.8.2003
# 查看容器是否有提交的容器
[harry@iZ87s60rq3uZ ~]$ sudo docker images
REPOSITORY                       TAG        IMAGE ID       CREATED          SIZE
harry88995/centos-vim-7.8.2003   latest     fccbf515c086   11 seconds ago   419MB
# 运行提交的新容器, 看下是否可以使用vim了~
[harry@iZ8vb7z0oswZ ~]$ sudo docker run -it harry88995/centos-vim-7.8.2003 bash
[root@864c47af69c4 /]# vim hello.txt
[root@864c47af69c4 /]# cat hello.txt 
Hello world! Good bye!

八、Dockerfile构建与使用

镜像时多层存储, 每一层在前一层的基础上进行修改;

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

刚才说了, 创建镜像的两个方法

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

官方提供的dockerfile实例

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

8.1 dockerfile主要组成部分:

基础镜像信息 FROM centos:7.9

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

容器启动时执行命令 CMD["/bin/bash"]

8.2 dockerfile指令

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

MAINTAINER 告诉别人, 谁负责养它? (指定维护者信息, 可以没有)

RUN 你想让它干啥 (在命令前面加上RUN即可)

ADD 添加宿主机的文件到容器内, **还多一个解压的功能**

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

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

WORKDIR 我是cd, 今天刚化了妆 (设置当前工作目录)

VOLUME 给它一个存放姓李的地方 (设置卷, 挂载主机目录)

EXPOSE 它要打开的门是啥 (指定对外的端口), 在容器内暴露一个窗口, 端口 EXPORT 80

CMD 奔跑吧, 兄弟! (指定容器启动后的要干的事情)

VOLUME 与 EXPOSE 数据目录与端口映射原理图解:
在这里插入图片描述

8.3 dockerfile其他指令:

COPY 复制指令

ENV 环境变量

ENTRYPOINT 容器启动后执行的命令

8.4 dockerfile实践

想自定义镜像, 就得自己写脚本, 也就是dockerfile了

需求, 通过dockerfile, 构建nginx镜像, 且运行容器后, 生成的界面, 是"Hello, good bye!"

# 1. 创建Dockerfile, 注意文件名, 必须是这个
[harry@iZ860rq3uZ learn_docker]$ pwd
/home/harry/learn_docker
[harry@iZ860rq3uZ learn_docker]$ cat Dockerfile 
FROM nginx
RUN echo '<meta charset=utf8>Hello, good bye!' > /usr/share/nginx/html/index.html
[harry@iZ860rq3uZ learn_docker]$

# 2. 构建dockerfile
docker build .
[harry@iZ860rq3uZ learn_docker]$ sudo docker build .
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM nginx
 ---> 605c77e624dd
Step 2/2 : RUN echo '<meta charset=utf8>Hello, good bye!' > /usr/share/nginx/html/index.html
 ---> Running in 9652b79e621a
Removing intermediate container 9652b79e621a
 ---> fc6bf2cfb402
Successfully built fc6bf2cfb402
[harry@iZ860rq3uZ learn_docker]$ chmod +x Dockerfile 

# 3. 修改镜像名
[harry@iZ8vb learn_docker]$ sudo docker tag fc6bf2cfb402 my_nginx

# 构建出的镜像如下
[harry@iZ83u learn_docker]$ sudo docker images
REPOSITORY  TAG        IMAGE ID       CREATED         SIZE
my_nginx    latest     fc6bf2cfb402   2 minutes ago   141MB

# 4. 运行该镜像
sudo docker run -d -p 777:80 my_nginx
[harry@iZ8vbbiuZ learn_docker]$ sudo docker run -d -p 777:80 my_nginx
993f992a96cefb785a83487d3fd5d292d373546ddbc1a953d4313ce448588a4b

# 4. 查看宿主机的777端口
http://39.101.240.154:777/
Hello, good bye! 

如下指令该怎么用?

# COPY
copy harry.py /home/

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

# ADD
ADD harry.tgz /home/
RUN linux命令 (XXX修改命令)

# CMD在容器内运行某个指令, 启动程序
# 该镜像在运行容器实例的时候, 执行的具体参数是什么

CMD ["参数1","参数2"]

CMD ["/bin/bash"]

# 该容器运行时, 执行的命令
# 等同于命令行的直接操作 docker run -it centos   cat /etc/os-release
CMD ["cat", "/etc/os-release"]

# CMD 有关启动程序的坑!

把宿主机安装, 启动nginx的理念放入dockerfile

  1. RUN yum install nginx
  2. RUN 配置文件修改 sed
  3. RUN systemctl start nginx ❌是错误的! 你的容器是启动不了的! 容器内的程序必须是前台运行的!
  4. 正确的应该是 CMD [“nginx”,"-g",“deamon off;”]

8.5 ENTRYPOINT和CMD的玩法

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

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

CMD xxx
ENTRYPOINT xxx

# 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"]

# 用法如下
docker run my_centos curl -s http://ipinfo.io/ip
#
docker run centos_curl

# 2.构建镜像
sudo docker buld .

# 3.查看结果
Successfully built 66f71c370c5a

# 4.检查镜像
[harry@iZ8vbq3uZ learn_docker]$ sudo docker tag 66f71c370c5a centos_curl
[harry@iZ8vbq3uZ learn_docker]$ sudo docker images
REPOSITORY    TAG        IMAGE ID       CREATED         SIZE
centos_curl   latest     66f71c370c5a   2 minutes ago   537MB

# 5.运行镜像, 生成容器记录, 没有前台运行, 因此立即挂了
[harry@iZ8vbbip4buZ learn_docker]$ sudo docker run centos_curl
39.101.240.154[harry@iZ8vbbip4buZ learn_docker]$ 

# 6.上述运行准确, 但是我想再传入一个参数, 该怎么办
# 发现是无法直接传入参数的, 该形式是覆盖镜像中的CMD
# 就好比把docker镜像, 当做一个环境, 去执行后面的命令
[harry@iZ8vbbip4buZ learn_docker]$ sudo docker run centos_curl pwd
/
[harry@iZ8vbbip4buZ learn_docker]$ sudo docker run centos_curl -I
docker: Error response from daemon: failed to create shim: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-I": executable file not found in $PATH: unknown.

# 7.想要正确的给容器传入一个 -I 参数, 该怎么办?
# 希望容器内能正确完成, 这个命令的执行
curl -s http://ipinfo.io/ip -I

# 8.解决办法1
# 给容器传入新的, 完整的命令
# 这是一个投机取巧的办法, 不合适
[harry@iZ8vbbip4buZ learn_docker]$ sudo 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: 14
date: Thu, 31 Mar 2022 01:47:27 GMT
x-envoy-upstream-service-time: 1
Via: 1.1 google

# 9.正确的姿势应该是使用 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"]

# 10.重新构建镜像
sudo docker build .

# 11.重新运行该镜像, 看结果, 以及传入新的参数
[harry@iZ8vbbiZ learn_docker]$ sudo docker tag d7de8a9749dd centos_curl_new

# 此时发现, 传入的CMD指令, 当做了ENTRYPOINT的参数
# 其实容器内, 执行的完整命令是: curl -s http://ipinfo.io/ip -I
[harry@iZ8vbbiZ learn_docker]$ sudo docker run centos_curl_new -I
HTTP/1.1 200 OK
access-control-allow-origin: *
content-type: text/html; charset=utf-8
content-length: 14
date: Thu, 31 Mar 2022 02:02:37 GMT
x-envoy-upstream-service-time: 1
Via: 1.1 google

8.6 ARG和ENV指令

设置环境变量

容器1 nginx

容器2 php-fpm

容器3 mysql

dockerfile 脚本, shell脚本

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

后续所有的操作, 通过 $NAME 可以直接获取变量值了, 维护dockerfile脚本更友好, 方便使用
ADD
COPY
EXPOSE

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

8.7 VOLUME

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

#  mount /mnt 挂载

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

# Dockerfile1
FROM centos
MAINTAINER harry
VOLUME ["/data1","/data2"]

# 该容器运行的时候, 这2个目录自动和宿主机的目录做好映射关系
sudo docker build .
# 运行该镜像
sudo docker run b18be2a2c940
# 查看生成的容器信息
[harry@iZ8vbbip4bq97z0o60rq3uZ learn_docker]$ sudo docker images
REPOSITORY     TAG        IMAGE ID       CREATED             SIZE
<none>         <none>     b18be2a2c940   11 seconds ago      203MB

# docker inspect命令查看
docker inspect 8f2b0de0df41

   "Volumes": {
                "/data1": {},
                "/data2": {}
            },
   "Mounts": [
            {
                "Type": "volume",
                "Name": "a1bdf01b92de0684f03b49023778a0c026e40ee32ccec285e9c46bacd29ebaee",
                "Source": "/var/lib/docker/volumes/a1bdf01b92de0684f03b49023778a0c026e40ee32ccec285e9c46bacd29ebaee/_data",
                "Destination": "/data1",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "1429e5198d7bb297ee3ded977a4cae6ab63312950ecb3d2a76bec7b814944f02",
                "Source": "/var/lib/docker/volumes/1429e5198d7bb297ee3ded977a4cae6ab63312950ecb3d2a76bec7b814944f02/_data",
                "Destination": "/data2",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],

1.容器数据挂载的方式, 通过dockerfile, 指定VOLUME目录

2.通过docker run -v 参数, 直接设置需要映射挂载的目录

8.8 EXPOSE

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

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

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

8.9 WORKDIR

用在dockerfile中, 目录的切换, 更换工作目录

WORKDIR /opt

8.10 USER

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

USER root
USER harry

十、构建一个网站镜像

1.nginx, 修改首页内容, html网站就跑起来了, web server , 提供web服务, 提供代理转发, 提供网关, 限流托等 …apache

2.web framework, web框架, 一般由开发, 通过某个开发语言, 基于某个web框架, 自己去开发一个web站点, python, diango框架

1.用python语言, 基于flask wen框架, 开发一个自己的网站, 写了一个后端的网站代码

2.开发dockerfile, 部署该代码, 生成镜像

3.其他人基于该镜像, docker run就可以在电脑跑起来这个网站

10.1 部署全流程

# 1.在宿主机下, 准备一个目录, 准备好dockerfile, 你的代码
# 写一个flask的python代码
[harry@iZ8vbbip4bq9q3uZ learn_docker]$ vim harry_flask.py 
[harry@iZ8vbbip4bq9q3uZ learn_docker]cat harry_flask.py 
# coding:utf8
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hell():
  return "hello docker, i am harry."
  if __name__ == "__main__":
    app.run(host='0.0.0.0', post=777)
    
# 2.编写dockerfile
touch Dockerfile

# 3.检查代码文件环境, 以及内容
[harry@iZ8vbbip4uZ learn_docker]$ ls
Dockerfile  harry_flask.py
[harry@iZ8vbbip4uZ learn_docker]$ cat Dockerfile 
FROM centos:7.8.2003
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://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 harry_flask.py /opt
WORKDIR /opt
EXPOSE 777
CMD ["python3","harry_flask.py"]
[harry@iZ8vbbip4uZ learn_docker]$

# 4.构建镜像
# --no-cache  不用缓存
sudo docker build --no-cache -t 'harry777/my_flask_web' .
# 最后的结果类似如下, 才是正确
Removing intermediate container e8e9da66a65d
 ---> b4ba1cb087a9
Successfully built b4ba1cb087a9
Successfully tagged harry777/my_flask_web:latest

[harry@iZ8vuZ learn_docker]$ sudo docker images
REPOSITORY             TAG        IMAGE ID       CREATED          SIZE
harry777/my_flask_web  latest     b4ba1cb087a9   36 seconds ago   715MB

# 5.运行镜像, 生成容器
docker run -d --name my_flask_web -p 777:777 harry777/my_flask_web 

# 6.访问宿主机, 看容器内的flask web 网页
http://39.101.240.154:777/hello
hello docker, i am harry.

# 7.如何修改网站的内容, 这个程序时跑在容器里了

10.2 如何修改该网站的内容

1.修改宿主机的代码, 以及Dockerfile, 重建应用

2.你可以进入到以及运行的容器内, 重启容器即可

# 1.进入容器
docker exec -it 容器id bash

# 2.修改容器内的程序
vim harry_flask.py

# 3.退出容器, 重启容器
exit
docker restart 容器id
docker ps # 看下是否存活

10.3 再次强调docker的好处, 用法

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

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

tomcat, jdk环境

当你有了docker

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

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

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

十一、总结

容器是docker的核心概念, 容器是一个或者一组应用, 它的运行状态如下:

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

在这里插入图片描述

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

上图可以理解

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

docker容器管理总结

# 运行容器, 且进入容器内
docker run -it ubuntu bash

# 容器运行web程序
# 注意端口的使用, 数字大一点, 8000以后开始使用
docker run --name my_nginx_9000 -d --restart=always -p 9000:80 nginx

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

# 查看容器内日志, 实时刷新
docker logs -f 

# 查看运行时, 以及挂掉的日志
docker ps 在运行的容器
#等同于
docker container ls

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

# 停止启动
docker start
docker stop

# 进入容器内
docker exec -it 容器id bash

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

# 查看容器进行进程信息
docker top 容器id

# 查看容器内资源
docker status 容器id

# 查看容器的具体信息
docker inspect 容器id

# 获取容器内的ip地址, 容器的格式化参数
docker inspect 容器id | grep ip段
# 拿到容器内ip
docker inspect --format '{{.NetworkSettings.IPAddress}}' 容器id

docker run 启动容器的时候, docker后台操作流程是

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

总结:

docker
什么是容器
容器VS虚拟机
docker优点
高效的利用系统资源
更快启动时间
一致性环境
轻松交付,部署
主流公司都在用
docker核心组成
安装部署
镜像加速器
生命周期
UnionFS
镜像管理
容器管理
仓库管理
dockerfile实践
构建docker镜像
部署一个用于运行你所需的容器环境
相当于一个脚本,通过dockerfile自己的命令,来构建软件依赖,文件依赖,存储等等....
指令合集
FROM MAINTAINR RUN ADD WORKDIR VOLUME EXPOSE CMD ENTRYPOINT ENV USER 还有很多, 根据需要学习
存储、网络、REST、API
容器编排
docker生产实践

文章就到这里, 喜欢的话点个关注和赞吧❤~

  • 3
    点赞
  • 9
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:我行我“速” 设计师:Amelia_0503 返回首页
评论

打赏作者

韩俊强

奖励一杯咖啡☕️

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

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

打赏作者

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

抵扣说明:

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

余额充值