docker

更多详细介绍请参见于超老师的博客，吐血推荐！！！

1.介绍

docker是linux容器的一种封装，提供简单易用的容器使用接口。它是最流行的Linux容器解决方案。
docker的接口相当简单，用户可以方便的创建、销毁容器。
docker将应用程序与程序的依赖，打包在一个文件里面。运行这个文件就会生成一个虚拟容器。
程序运行在虚拟容器里，如同在真实物理机上运行一样，有了docker，就不用担心环境问题了。

2.安装

2.1.官方安装正确姿势

[请遵循官方安装方式！！！]

(https://docs.docker.com/install/linux/docker-ce/centos/#upgrade-docker-after-using-the-convenience-script)

官方教程如下，最正确安装docker姿势

  1. 卸载旧版本

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

  2. 设置存储库

    sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

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

  3. 安装docker社区版

    sudo yum install docker-ce

  4. 启动关闭docker

    systemctl start docker

2.2.docker版本说明

Docker 是一个开源的商业产品，有两个版本：社区版（Community Edition，缩写为 CE）和企业版（Enterprise Edition，缩写为 EE）。
企业版包含了一些收费服务，个人开发者一般用不到。本文的介绍都针对社区版。

2.3.系统环境说明

docker最低支持centos7且在64位平台上，内核版本在3.10以上
[root@oldboy_python ~ 10:48:11]#uname -r
3.10.0-693.el7.x86_64

2.4.Docker镜像加速器

DaoCloud 加速器 是广受欢迎的 Docker 工具，解决了国内用户访问 Docker Hub 缓慢的问题。DaoCloud 加速器结合国内的 CDN 服务与协议层优化，成倍的提升了下载速度。

使用前请先确保您的 Docker 版本在 1.8 或更高版本，否则无法使用加速。

教程官网

# 编辑文件
vim /etc/docker/daemon.json #修改这个文件为如下内容
{
    "registry-mirrors": [
        "http://95822026.m.daocloud.io"
    ],
    "insecure-registries": []
}

# 或者使用以下命令
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://95822026.m.daocloud.io

# 事后重启docker
systemctl restart docker

3.Docker容器、镜像的增删改查命令

3.1.镜像相关命令

  1. 查看服务器所有镜像文件

    # 镜像的ID唯一标识了镜像，如果ID相同,说明是同一镜像。
# TAG信息来区分不同发行版本，如果不指定具体标记,默认使用latest标记信息。

[root@docker ~]# docker images  #查看docker镜像 或者使用 docker image ls

REPOSITORY(来自那个仓库)       TAG(标签)            IMAGE ID(唯一ID)         CREATED(创建时间)         VIRTUAL SIZE(大小)

docker.io/centos               latest              60e65a8e4030           	5days ago				196.6 MB
              
docker.io/nginx                latest              813e3731b203             13days ago				133.8 MB
...

  2. 搜索镜像

    [root@docker ~]# docker search centos  #搜索所有centos的docker镜像

INDEX                NAME(名称)                  DESCRIPTION(描述)                   STARS(下载次数)		OFFICIAL(官方)        AUTOMATED(自动化)

docker.io           docker.io/centos         The official build of CentOS.        		1781               		[OK]

docker.io   docker.io/jdeathe/centos-ssh     CentOS-6 6.7 x86_64 /             			14                                             [OK]

……

  3. 获取镜像

    # 可以使用docker pull命令来从仓库获取所需要的镜像。下面的例子将从Docker Hub仓库下载一个Centos操作系统的镜像。

[root@docker ~]# docker pull centos  #获取centos镜像

[root@docker ~]# docker run -it centos /bin/bash  #完成后可以使用该镜像创建一个容器

  4. 删除镜像

    # 如果要移除本地的镜像,可以使用docker rmi命令(在删除镜像之前先用docker rm删除依赖于这个镜像的所有容器)。注意docker rm 命令是移除容器。

[root@docker ~]# docker rmi imageID  # 根据镜像的ID删除docker镜像，imageID为要删除的镜像id的前3位即可，必须要先删除有相关依赖的容器进程记录

  5. 导出镜像

    # 如果要导出镜像到本地文件,可以使用docker save命令。官方文档解释的是，docker save用的是tar命令压缩，应该是没有其他压缩格式的

[root@docker ~]# docker save centos > /opt/centos.tar.gz  # 导出docker镜像至本地

# 查看下导出的镜像
[root@docker ~]# ll /opt/
-rw-r--r--.1 root root 204205056 12月 30 09:53 centos.tar.gz

  6. 导入镜像

    # 可以使用docker load从本地文件中导入到本地docker镜像库

[root@docker ~]# docker load < /opt/centos.tar.gz   #导入本地镜像到docker镜像库

[root@docker~]# docker images  #查看镜像导入情况

REPOSITORY           TAG                 IMAGE ID            CREATED             VIRTUAL SIZE

docker.io/centos     latest              60e65a8e4030        5 days ago          196.6 MB

3.2.容器相关命令

  1. 启动容器的方式

    # 启动容器有两种方式:
1.一种是基于镜像新建一个容器并启动，
2.另外一个是将在终止状态(stopped)的容器重新启动。

因为Docker的容器实在太轻量级了，很多时候用户都是随时删除和新创建容器。

  2. 新建并且启动容器

    # 所需要的命令主要为 docker run 镜像名

# 1.例如,下面的命令输出一个hehe,之后终止容器。
[root@docker ~]# docker run centos /bin/echo "hehe"  # 这跟在本地直接执行 /bin/echo'hehe' 

hehe

 
# 2.启动一个bash终端,允许用户进行交互。
[root@docker ~]# docker run --name mydocker -it centos /bin/bash 

[root@1c6c3f38ea07 /]# pwd
/

[root@1c6c3f38ea07 /]# ls
anaconda-post.log  bindev  etc  homelib  lib64  lost+foundmedia  mnt  optproc  root  runsbin  srv  systmp  usr  var

 
# 启动相关参数：
1.--name:给容器定义一个名称

2.-i:则让容器的标准输入保持打开。

3.-t:让Docker分配一个伪终端,并绑定到容器的标准输入上

4./bin/bash:执行一个命令

    当使用 docker run 创建运行容器时，后台做了什么？

    1.检查本地是否存在指定的镜像，不存在就从公有仓库下载

2.利用镜像创建并启动一个容器

3.分配一个文件系统，并在只读的镜像层外面挂在一层可读写层

4.从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去

5.从地址池配置一个ip地址给容器

6.执行用户指定的应用程序

7.执行完毕后容器被终止

  3. 检查容器进程

    # 1.检查当前运行中的docker容器进程
docker ps

# 2.检查所有运行过的容器
docker ps -a

  4. 示例1：获取镜像、创建容器、运行容器示例

    # hello world是程序员启蒙语言，我们通过最简单的image文件“hello-world”，来感受一下docker。
# 1.获取镜像 hello-world
docker pull hello-world

# 2.检查镜像
docker images

# 3.运行image文件,可以用容器id
docker run hello-world  

# 4.检查docker容器进程
docker ps

# 5.检查所有运行过的容器
docker ps -a

  5. 示例2：在当前系统运行一个 Ubuntu 容器

    咱们要在cenots7操作系统下，以docker下载一个ubuntu image文件，然后以image启动容器

    # 1.下载镜像  
	# 如下所示，乌班图的镜像下载，是下载每一层的文件Trying to pull repository docker.io/library/ubuntu ... 
    [root@oldboy_python ~ 11:52:22]#docker pull ubuntu
    14.04: Pulling from docker.io/library/ubuntu
    8284e13a281d: Pull complete 
    26e1916a9297: Pull complete 
    4102fc66d4ab: Pull complete 
    1cf2b01777b2: Pull complete 
    7f7a2d5e04ed: Pull complete 
    Digest: sha256:4851d1986c90c60f3b19009824c417c4a0426e9cf38ecfeb28598457cefe3f56
    Status: Downloaded newer image for docker.io/ubuntu:14.04
    # 下载过程可以看出镜像是由多层存储构成的。下载也是一层一层，并非单一的文件。
    # 下载过程中给出每一层的前12位ID。下载结束后会给出sha246的文件一致性校验值。
# 2.运行下载的容器
	[root@oldboy_python ~ 12:18:53]#docker run -it --rm ubuntu bash  # 此时会进入交互式的shell界面，即可以使用乌班图操作系统
    root@3efbb2749d7c:/# cat /etc/os-release  
    NAME="Ubuntu"
    VERSION="20.04.4 LTS (Focal Fossa)"
    ID=ubuntu
    ID_LIKE=debian
    PRETTY_NAME="20.04.4 LTS"
    VERSION_ID="20.04"
    HOME_URL="http://www.ubuntu.com/"
    SUPPORT_URL="http://help.ubuntu.com/"
    BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"  
    
    # 使用exit退出容器exit
    # docker run就是运行容器的命令。
    # 参数：
    # -it ： 	-i 是交互式操作，-t是终端
    # -rm  :   	 容器退出后将其删除。也可以不指定参数，手动docker rm进行删除。使用-rm可以避免浪费空间。 
    # ubuntu:    这指的是镜像文件 
    # bash   :   指定用交互式的shell，因此需要bash命令

  6. 查看容器内标准输出

    docker logs 容器ID前3位

  7. 停止容器

    docker stop 容器ID前3位

  8. 启动容器

    docker start 容器ID前3位

  9. 删除容器

    docker rm 容器ID前3位

  10. 进入容器

    使用-d参数时，容器启动后会进入后台。某些时候需要进入容器进行操作,有很多种方法，包括使用docker attach命令或nsenter工具等。

    docker  exec -it 容器id
docker attach 容器id

  11. 查看容器内进程

    [root@oldboy_python ~ 16:49:05]#docker top 容器ID前三位
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                3926                3912                0                   16:46               ?                   00:00:00            python app.py

  12. 案例3：后台模式启动docker

    -d参数：后台运行容器，返回容器ID

    # 后台模式启动一个centos容器，容器内每秒打印“hello centos”
# 1.启动容器
[root@oldboy_python ~ 15:58:14]#docker run -d centos /bin/sh -c "while true;do echo hello centos; sleep 1;done"
c0283f1077d16a2bf2597e269d51a02815334f7390f18a62ed7a4ba07f351b65

# 2.检查容器进程
[root@oldboy_python ~ 15:58:22]#docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
c0283f1077d1        centos              "/bin/sh -c 'while..."   6 seconds ago       Up 5 seconds                            fervent_turing
[root@oldboy_python ~ 15:58:28]#

# 3.查看容器内的标准输出
docker logs c02

# 4.停止容器
docker stop c02

# 5.启动容器
docker start c02

# 6.删除容器
docker rm c02

3.3.提交创建自定义的镜像

# 1.我们进入交互式的centos容器中，发现没有vim命令
docker run -it centos
# 2.在当前容器中，安装一个vim
yum install -y vim
# 3.安装好vim之后，exit退出容器
exit
# 4.查看刚才安装好vim的容器记录
docker ps -a  # 或者 docker container ls -a
# 5.提交这个容器，创建新的image
docker commit 容器的id dudu/centos-vim
# 6.查看镜像文件
[root@master /home]docker images
REPOSITORY         TAG       IMAGE ID       CREATED          SIZE
dudu/centos8-vim   latest    8c1809b3da15   47 seconds ago   298MB  # 这个就是我们创建的镜像
python             latest    73381281305e   5 days ago       919MB
ubuntu             latest    ff0fea8310f3   2 weeks ago      72.8MB
hello-world        latest    feb5d9fea6a5   6 months ago     13.3kB
centos             latest    5d0da3dc9764   6 months ago     231MB
增删改查命令汇总
1.增
1.搜索相关的镜像
	docker search  python3 

2.从dockerhub 仓库中获取docker的镜像，从github获取代码一个道理
    docker  pull centos  #去docker仓库中寻找centos系统镜像
    docker  pull  ubuntu  #获取ubuntu镜像
    docker pull ubuntu  # 获取一个ubuntu镜像

3.获取一个hello-world进程
	docker  pull hello-world

#比如你想用nginx，又不想修改宿主机的一个软件环境，直接用docker安装
    docker search  nginx 
    docker pull nginx
    docker run nginx  #nginx服务器就能够运行在容器中，然后和宿主机有一个端口映射，就可以访问了
2.删
1.删除本地镜像文件
    docker rmi   镜像id
    docker rmi  fce  #删除镜像id的前3位即可，必须要先删除有相关依赖的容器进程记录

2.删除容器记录的命令
	docker rm   容器id前3位 

3.批量清空无用的docker容器记录，容器记录非常容易创建docker run  
# 批量删除挂掉的容器记录
	docker rm  `docker ps -aq`  #  把docker容器记录的id号，保存在反引号中，丢给docker rm实现批量删除

4.批量删除镜像
	docker rmi `docker iamges -aq`

5.批量停止容器
    docker stop `docker ps -aq`
    docker start 容器id #启动暂停的容器
    docker stop 容器id  #暂停一个容器
    docker restart 容器id  #重启容器
3.改
1.运行第一个docker的容器实例，运行镜像文件，产生容器进程
    docker run   镜像文件的名字即可
    docker run  centos  # 运行centos基础镜像，如果docker容器中没有在后台运行的进程，容器会直接挂掉
    # 如果你发现你的容器没有启动成功，说明容器内部出错了，程序没有运行

2.运行一个hello world容器进程
	docker run hello-world

3.docker run指令还有一个功能是，当镜像不存在的时候，会自动去下载该进程
    此时老师的电脑，本地没有hello-world镜像了
    docker run hello-world   #有2个功能，下载镜像，执行镜像

4.交互式的运行一个存活的docker容器，centos

    # -it参数  -i 是交互式的命令操作   -t开启一个终端   /bin/bash 指定shell解释器
    # 容器空间内，有自己的文件系统 
    docker run -it  centos  /bin/bash 	#运行centos镜像，且进入容器内
    [root@s25linux ~]# docker run  -it  centos  /bin/bash		#进入容器后，容器空间内是以容器id命名的
    [root@fc760671d074 /]#

5.运行出一个活着的容器，在后台不断执行程序的容器
    #  docker run  运行镜像文件
    #  -d 是让容器后台运行
    #  -c 指定一段shell代码

	# 运行centos镜像，生成容器实例，且有一段shell代码，在后台不断运行，死循环打印一句话，每秒钟打印一次
	docker run -d centos /bin/sh -c "while true;do echo s25的靓仔们辛苦了学习linux; sleep 1;done"

6.运行docker容器，且指定名字，便于管理
	docker run --name "指定容器的运行名字“    -d centos /bin/sh -c "while true;do echo s25的靓仔们辛苦了学习linux; sleep 1;done"

7.进入一个正在运行的容器空间，进入一个线上正在运行的容器程序，修改其内部的资料
    docker exec -it  容器id   /bin/bash  

8.如何进入容器空间内，修改容器内的环境，以及代码等内容，修改软件等操作，且提交镜像，发送给其他人
    8.1 进入容器空间内，安装一个vim或是python3等步骤
    docker run -it centos /bin/bash
    yum install vim -y 

    8.2  安装好vim后，退出容器空间
    exit

    8.3 提交该容器，生成新的镜像文件
    docker commit  5b28d8c88794  s25-centos-vim

9.导出你的docker镜像，可以发送给同事，或是其他人使用
    docker save  镜像id   >   镜像的压缩文件
    #官方文档解释的是，docker save用的是tar命令压缩，应该是没有其他压缩格式的
    [root@s25linux ~]# docker save  45d7f887125d   >   /opt/s25-centos-vim.tar.gz
    #你可以删掉本地的镜像，然后重新导入该压缩文件，模拟发送给同事的操作

10.如何进行docker镜像导入 
    比如小李运维同志，他收到了该docker镜像压缩文件，在他的机器上导入该进项
    docker  load   <   /opt/s25-centos-vim.tar.gz
    首次导入该进项的时候，发现丢失了镜像tag标签，重新赋予一个即可
    docker tag  45d7f887125d  s25-new-centos-vim

11.如何在docker内，运行一个python web的程序，需要用到端口映射知识~~~~
    #  -d 后台运行 
    # -P  大写的P参数，作用是随机的端口映射
    # training/webapp 是镜像的名字，默认没有会去在线下载
    # python app.py   代表启动容器后，让容器执行的命令是它
    # 因此这个命令作用是，启动一个webapp镜像，且在容器中执行 python app.py  
    # -p 6000:5000  访问宿主机的6000，就是访问容器的5000了
    docker run --name "s25webdocker"  -d -p 6000:5000 training/webapp python app.py  

12.进入该webapp的容器，查看里面的内容
    docker exec -it  容器id   /bin/bash  #进入容器内，可以进行相应的修改操作
    docker restart  容器id  #重启该容器，重新读取代码，即可生效

对于后端开发的程序员，只需要掌握Docker的容器，镜像，仓库的增删改查命令即可

4.查
1.查看本地机器，所有的镜像文件内容
	docker  images # 或者使用 docker image ls

2.查看docker正在运行的进程
	docker ps 

3.查看所有运行，以及挂掉的容器进程
	docker ps -a  

4.查看容器内的运行日志
    docker logs  容器id
    docker logs -f  容器id   #实时刷新容器内的日志，例如检测nginx等日志信息

5.查看容器内的端口转发情况
    docker port  容器id  #查看容器的端口转发
    [root@s25linux ~]# docker port 615  
    5000/tcp -> 0.0.0.0:6000

4.端口映射

image-20220313233208465

容器中可以运行网络应用，但是要让外部也可以访问这些应用，可以通过-p或-P参数指定端口映射。

4.1.开启端口映射

# -P 参数会随机映射端口到容器开放的网络端口
[root@oldboy_python ~ 16:31:37]#docker run -d -P training/webapp python app.py

4.2.检查映射的端口

# docker ps -l
# 宿主机ip:32768 映射容器的5000端口
[root@oldboy_python ~ 16:34:02]#docker ps -l
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
cfd632821d7a        training/webapp     "python app.py"     21 seconds ago      Up 20 seconds       0.0.0.0:32768->5000/tcp   brave_fermi

4.3.查看容器日志信息

# 不间断显示log
docker logs -f cfd

4.4.指定映射端口

# 指定服务器的9000端口，映射到容器内的5000端口
[root@oldboy_python ~ 16:46:13]#docker run -d -p 9000:5000 training/webapp python app.py
c0b5a6278d0f4f2e9b9eba8680451111d8b911b61de0c37ea64cb337aefb854e

4.5.查看指定容器的端口映射

[root@oldboy_python ~ 16:49:01]#docker port c0b
5000/tcp -> 0.0.0.0:9000

5.dockerfile

5.1.常用指令

# 1.FROM 指令表示，告诉该dockerfile以哪个镜像为基础
    # 比如你的技术老大，要求你们程序运行在ubuntu中
    # FROM  ubuntu
    # FROM  centos
    FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
    FROM centos #使用base image
    FROM ubuntu:14.04 #带有tag的base image


# 2.LABEL标签，定义变量，定义作者信息等
    LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
    LABEL maintainer=“yc_uuu@163.com"

# 3.RUN是一个万能指令，你可以用它在docker中执行任意的命令
    # RUN就是告诉容器要做哪些配置

    # 用RUN指令告诉dockerfile他该去做什么事
    RUN mkdir  /s25牛批
    RUN cd  /s25牛批
    RUN cd
    RUN pwd  #会输出什么？ 因此在容器中会输出，用户家目录

    # 对于复杂的RUN命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
    # 要修改centos基础镜像的环境问题
    RUN yum update && yum install -y vim \
        Python-dev #反斜线换行
    RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME”


# 4.WORKDIR 
    WORKDIR /root # 相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
    WORKDIR /test # 如果没有就自动创建
    WORKDIR demo # 再进入demo文件夹
    RUN pwd     # 打印结果应该是/test/demo

    # 案例
    WORKDIR /s25很棒
    WORKDIR  我们要说goodbay了
    RUN  pwd  # 会输出什么？ /s25很棒/我们要说goodbay了  此时进入了2层目录


# 5.ADD指令用于添加宿主机的文件，放入到容器空间内 
    # 宿主机有自己的文件系统，文件夹，文件，目录等
    # 容器内也有一套自己的文件系统，独立的文件信息
    # 把宿主机的代码，拷贝到容器内
    # ADD还有解压缩的功能，这是一个坑，需要注意
    ADD and COPY 
    ADD hello.txt /opt  #吧宿主机的hello.txt 拷贝到容器内的/opt目录下 
    ADD test.tar.gz /opt    /opt/test  
    RUN tar -zxvf test.tar.gz  #直接报错，文件不存在 ，因为上一步，ADD指令已经对tar.gz压缩包解压缩了

    WORKDIR /root
    ADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
    COPY hello test/  #等同于上述ADD效果

# 6.COPY
    # dockerfile，用于从宿主机拷贝文件，到容器内有2个指令一个ADD，一个COPY，COPY仅仅就是拷贝，尽量用它
    ADD与COPY
       - 优先使用COPY命令
        -ADD除了COPY功能还有解压功能

#7. 添加远程文件/目录使用curl或wget

# 8.ENV
    ENV #环境变量，尽可能使用ENV增加可维护性
    ENV MYSQL_VERSION 8.0 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 

    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
    RUN yum install -y mysql-server=“${MYSQL_VERSION}”

5.2.dockfile实战，写一个flask容器脚本

  1. 准备好一个flask代码，检查需要哪些依赖步骤

    [root@s25linux s25docker]# cat s25_flask.py

from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
    return "linux就即将结束了，祝大家，找到好工作，有linux问题呢，尽量和我来沟通，互相学习"
if __name__=="__main__":
    app.run(host='0.0.0.0',port=8080)

  2. 在宿主机环境检查如何能够运行该脚本

    # 发现需要安装flask模块
pip3 install -i https://pypi.douban.com/simple flask

  3. 编写dockerfile脚本，注意名字必须是 大写Dockerfile

    touch Dockerfile ，写入如下的内容

FROM python    #指定镜像，dockerhub提供好的python镜像，已经安装好了python3，很好用
RUN pip3 install -i https://pypi.douban.com/simple flask  #在容器内安装flask模块  
ADD  s25_flask.py    /opt	#把宿主机的代码，拷贝到容器的/opt目录下
WORKDIR  /opt		#容器内进行目录切换
EXPOSE 8080		#打开容器的8080端口，用于和宿主机进行映射
CMD ["python3","s25_flask.py"]  	#在容器启动后，内部自动执行的命令是什么

  4. 检查准备的脚本代码，以及Dockerfile文件

    [root@s25linux s25docker]# ls
Dockerfile  s25_flask.py

  5. 构建该dockerfile，生成镜像

    [root@s25linux s25docker]# docker build .

  6. 检查docker的镜像，是否生成

    docker images 
#可以修改一下镜像的标签
[root@s25linux s25docker]# docker tag  a66  s25-flask

  7. 运行该镜像文件，查看是否能够运行容器内的flask

    docker run  -d  -p  8000:8080  a66

  8. 访问宿主机端口，查看容器内的应用

    curl  127.0.0.1:8000

  9. 可以修改容器内的代码，重启容器

    docker exec -it  88a5  /bin/bash  
# 修改容器内的代码
sed  -i "s/linux就即将结束了，祝大家，找到好工作，有linux问题呢，尽量和我来沟通，互相学习/linux课程结束，再回！朋友们/"  s25_flask.py

  10. 重启容器

    docker restart 88a

  11. 再次访问容器内应用，查看更新的代码内容

    curl  127.0.0.1:8000

6.dockerhub仓库

dockerhub仓库就是和github一样的概念

github—托管程序员的代码

dockerhub----托管程序员编写的docker镜像

image-20220313235336651

  1. docker提供了一个类似于github的仓库dockerhub,

  2. 注册docker id后，在linux中登录dockerhub，会提示让你输入账号密码，正确登录之后，本台机器就和dockerhub绑定账号了，你的镜像推送，就能够推送到，该账户的dockerhub中

    docker login
# 2.1准备镜像推送
    # 注意要保证image的tag是dockerhub账户名，如果镜像名字不对，需要改一下tag

    docker tag 镜像id  dockerhub的账号/centos-vim
    语法是：  docker tag   仓库名   yuchao163/仓库名

  3. 推送docker image到dockerhub，好比你准备git push 推送代码一样

    docker push dockerhub账号/centos-vim

  4. 在dockerhub中检查镜像,查看个人账户中的镜像文件

    https://hub.docker.com/

  5. 删除本地镜像，测试下载pull 镜像文件

    docker pull yuchao163/centos-vim
# docker # linux
Logo
Linux

更多推荐

网卡速率和双工模式的配置

http://linux.chinaitlab.com/system/792187.html1、mii-tool 配置网络设备协商方式的工具；    1.1 mii-tool 介绍；    mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

avatar Linux

Linux虚拟文件系统之文件系统卸载（sys_umount())

Linux中卸载文件系统由umount系统调用实现，入口函数为sys_umount()。较于文件系统的安装较为简单，下面是具体的实现。1. /*sys_umont系统调用*/2. SYSCALL_DEFINE2(umount, char __user *, name, int, flags)3. {4.struct path path;

avatar Linux

Linux系统下超级终端Minicom的使用方法（例如：连接交换机，路由器等）转http://baike.baidu.com/view/2911642.htm?fr=ala0_1

<br />　　Linux系统下超级终端Minicom的使用方法 <br />　　Linux下的Minicom的功能与下的超级终端功能相似，适于在通过超级终端对设备的管理以及对嵌入操作系统的升级，现写出Minicom的使用手册： <br />　　1． 启动minicom <br />　　以root权限登录系统 <br />　　使用命令 <br />　　minicom –s 则minicom启动，屏

avatar Linux