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 1230 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   容器id33.批量清空无用的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 
    
Logo

更多推荐