Docker

Docker学习

docker简介

什么是docker

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口

docker的设计思想

Docker的思想来自于集装箱，集装箱解决了什么问题？在一艘大船上，可以把货物规整的摆放起来。并且各种各样的货物被集装箱标准化了，集装箱和集装箱之间不会互相影响。那么我就不需要专门运送水果的船和专门运送化学品的船了。只要这些货物在集装箱里封装的好好的，那我就可以用一艘大船把他们都运走。

docker就是类似的理念。现在都流行云计算了，云计算就好比大货轮。docker就是集装箱。

1.不同的应用程序可能会有不同的应用环境，比如.net开发的网站和php开发的网站依赖的软件就不一样，如果把他们依赖的软件都安装在一个服务器上就要调试很久，而且很麻烦，还会造成一些冲突。比如IIS和Apache访问端口冲突。这个时候你就要隔离.net开发的网站和php开发的网站。常规来讲，我们可以在服务器上创建不同的虚拟机在不同的虚拟机上放置不同的应用，但是虚拟机开销比较高。docker可以实现虚拟机隔离应用环境的功能，并且开销比虚拟机小，小就意味着省钱了。

2.你开发软件的时候用的是Ubuntu，但是运维管理的都是centos，运维在把你的软件从开发环境转移到生产环境的时候就会遇到一些Ubuntu转centos的问题，比如：有个特殊版本的数据库，只有Ubuntu支持，centos不支持，在转移的过程当中运维就得想办法解决这样的问题。这时候要是有docker你就可以把开发环境直接封装转移给运维，运维直接部署你给他的docker就可以了。而且部署速度快。

3.在服务器负载方面，如果你单独开一个虚拟机，那么虚拟机会占用空闲内存的，docker部署的话，这些内存就会利用起来。

总之docker就是集装箱原理。

docker和虚拟技术比较

传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程

而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便

每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。

docker下载

1，官网 http://www.docker.com

2，中文官网 https://docker-cn.com

3，仓库 https://hub.docker.com

docker安装前说明

Docker支持以下的CentOS版本:

CentOS 7(64-bit)

CentOS 6.5(64-bit)或更高的版本

前提条件

目前，CentOS 仅发行版本中的内核支持 Docker。

Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上(使用命令uname -r 可以查看自己的内核版本)。

Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本

docker安装

1 centos 下安装Docker 文档

https://docs.docker.com/install/linux/docker-ce/centos/

2 Docker 安装

2.1 确定是centos7的版本

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-odQWSyR1-1608711842817)(file:///C:/Users/26918/AppData/Local/Temp/msohtmlclip1/01/clip_image001.png)]

2.2 yum安装gcc相关

1，确定centos7能上外网
2，yum -y install gcc
3，yum -y install gcc-c++

2.3 卸载旧版本

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

2.4 安装方法

yum install docker

2.5 启动docker

systemctl start docker	#启动docker
systemctl stop docker	#停止docker
systemctl restart docker #重启docker
systemctl enable docker #开机自启

2.6 查看版本

docker version

2.7 测试运行 hello-world

1> echo "DOCKER_OPTS=\"\$DOCKER_OPTS --registry-mirror=http://f2d6cb40.m.daocloud.io\"" | sudo tee -a /etc/default/docker #使用国内的Docker仓库daocloud
2> sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #修改为阿里云的docker镜像
docker pull hello-world #拉取镜像
docker run hello-world  #运行镜像

由于本地没有hello-world这个镜像，所以会下载一个hello-world的镜像，并在容器内运行。

2.8 测试运行nginx

docker run -p 8080:80 -d docker.io/nginx #将80端口映射为8080,或者80:80还是原先的80端口,不可以不写

2.9 卸载docker

systemctl stop docker  # 停止docker
yum -y remover docker  # 卸载docker
rm -rf /var/lib/docker

docker加速配置

为什么要加速

因为docker的运行需要在本地有相关的镜像，如果本地没有，就会去镜像仓库里面下载到本地，再运行，有时候下载比较慢，所以要配置镜像加速

阿里云的加速

加速网站

https://homenew.console.aliyun.com/

https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

进入后搜索 容器镜像服务，点击镜像加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://2q3sarfp.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

docker命令[帮助+镜像]

帮助命令

docker version 查看docker版本
docker info	   显示全系统信息
docker --help  显示docker相关的所有命令及功能说明

镜像命令

docker images:列出本机上的镜像

REPOSITORY:表示仓库的地址
TAG:镜像的标签
IMAGE ID:镜像ID
CREATED:镜像创建时间
SIZE:镜像大小
可选项:
	-a 列表本地的所有镜像及子镜像
	-q 只显示镜像ID
	--digests 显示镜像的摘要信息
	--no-trunc 显示完整的镜像信息

docker search 镜像搜索命令

搜索网站:https://hub.docker.com

docker search 镜像名称

-[options] 说明

docker search -s 3000 镜像名称

-s列出收藏数不少于指定值(3000)的镜像

docker pull镜像下载命令

docker pull 镜像名称:[TAG]
例如:docker pull tomcat:8.5  下载8.5的镜像版本
	docker pull docker 默认下载最新的tomcat镜像版本[latest]

docker rmi镜像删除命令

根据镜像ID删除

docker rmi ID

根据镜像仓库名称删除

docker rmi hello-world

批量删除镜像

docker rmi id id

删除全部镜像

docker rmi -f $(docker images -q)

docker命令[容器]

什么是容器

容器镜像是一个软件的轻量级独立可执行软件包，包含运行它所需的一切：代码，运行时，系统工具，系统库，设置。不管环境如何，集装箱化软件都可以运行相同的Linux和Windows应用程序。容器将软件与其周围环境隔离开来，例如开发环境和生产环境之间的差异，并有助于减少在同一基础架构上运行不同软件的团队之间的冲突。

1.轻量级

在一台机器上运行的Docker容器共享该机器的操作系统内核; 他们立即开始并使用更少的计算和内存。图像由文件系统层构建并共享公用文件。这最大限度地减少了磁盘使用量，图像下载速度更快。

2.标准

Docker容器基于开放标准，可在所有主要Linux发行版，Microsoft Windows以及任何基础架构（包括虚拟机，裸机和云中）上运行。

3.安全

Docker容器将应用程序彼此隔离并从底层基础架构中分离出来。Docker提供了最强大的默认隔离功能，可以将应用程序问题限制在一个容器中，而不是整个机器上。

演示前提

有镜像才能创建容器,这个是根本要求(下载centos镜像来演示)

docker pull centos

创建并启动容器

3.1 语法

这个是创建并启动,如果之后退出了容器,那么再次启动容器时需要用到下面 启停容器 的命令

docker run [option] images [command][args]

3.2 option说明

有些是一个减号，有些是两个减号

–name=“容器新名字”: 为容器指定一个名称；

-d: 后台运行容器，并返回容器ID，也即启动守护式容器；

-i：以交互模式运行容器，通常与 -t 同时使用；

-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；

-P: 随机端口映射；

-p: 指定端口映射，有以下四种格式

ip:hostPort:containerPort

ip::containerPort

hostPort:containerPort

containerPort

3.3 交互式运行

docker run -it centos /bin/bash
docker run -it --name mycentos01 centos /bin/bash

直接进入了容器

退出容器

exit #退出容器并关闭容器
ctrl+p+q  #退出不关闭容器

列出所有容器

​ 语法

• docker ps [option]
  

​ 默认只列出正在运行的容器

​ option 参数说明

​ -a 显示所有运行和没有运行的容器

​ -l 显示最近创建的容器

​ -n 显示最近n个创建的容器

​ -q 静默模式,只显示容器编号

​ --no-trunc 不截断输出

启停容器

启动容器针对的是已经有了的容器,如果没有则需要先创建(run) 容器

docker restart 容器ID/容器名称 # 重启容器
docker start 容器ID/容器名称   # 启动容器
docker stop 容器ID/容器名称	 # 关闭容器
docker kill 容器ID/容器名称    # 强制停止容器

删除已停止的容器

# 单个删除
docker rm 容器ID
# 多个删除
docker rm -f $(docker ps -aq)
docker ps -aq xargs docker rm

其他重点内容

1.启动守护式容器

使用镜像centos:lates已后台模式启动一个容器

docker run -d centos

问题:docker ps -a进行查看,会发现容器已经退出

很重要的一点说明:docker容器后台运行,就必须有一个前台程序

容器运行的命令如果不是哪些一直挂起的命令(比如运行top，tall),就是会自动退出的

这个是docker的机制问题,比如你的web容器,我们以nginx为例,正常情况下,我们配置启动服务只需要启动对应的service即可,例如 service nginx start

但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用

这样的容器后台启动后,会立即自杀因为他觉得没事可做了

所以,最佳的解决方案是,将你要运行的程序以前台进程的形式运行

2.查看容器日志

如果是后台运行的程序，那么如何查看运行的日志呢？

• 启动一个tomcat

  docker run -d -p 8080:8080 tomcat:8.5

• 使用日志命令查看tomcat的输出日志

  docker logs -tf --tail 5 容器ID
  	-t 是加入时间戳
  	-f 跟随最新的日志打印
  	--tail 数字 显示最后多少条
  

3.查看容器运行进程

docker top 容器ID

4.查看容器内部细节

docker inspect 容器ID

5.进入正在进行的容器并以命令行进行交互

# 方式一 重新打开一个终端 如果以这种方式进入容器，可以使用exit退出.而不会关闭容器
docker exec -it 容器ID /bin/bash
# 方式二 这种方式里面使用exit退出会关闭容器 如果不想关闭容器必须使用ctrl+p+q
docker attach 容器ID
# 两种方式的区别
exec 在容器中打开新的终端 并且可以启动新的进程
attach 直接进行容器终端 不会启动新的进程

6.进入容器内拷贝文件到主机

docker cp 容器ID:容器内的路径 主机目录

docker镜像详解

什么是镜像

UnionFS(联合文件系统)

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

分层的镜像

以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

为什么docker要使用上面的这种分层结构

最大的一个好处就是 - 共享资源

比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，

同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享

镜像的特点

docker镜像都是只读的

当容器启动时，一个新的可写的镜像被加载到镜像层的顶部。

这一层通常被叫做容器层，容器层之下的都叫镜像层

镜像的commit操作

作用

当镜像运行之后可以修改容器里面的内容，再提交成一个新的镜像

命令语法

docker commit -m='新的镜像的描述信息' -a='作者' 容器ID 要创建的目标镜像名:[标签名]

docker命令总结

docker容器数据卷

什么是容器数据卷

先来看看Docker的理念：

* 将应用与运行的环境打包形成容器运行 ，运行可以伴随着容器，但是我们对数据的要求希望是持久化的

* 容器之间希望有可能共享数据

Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，

那么当容器删除后，数据自然也就没有了。

为了能保存数据在docker中我们使用卷

容器数据卷能做什么

1.容器数据的持久化

2.容器之间继承和共享数据

添加数据卷的方式

直接使用命令添加

添加容器卷的语法

# 语法
docker run -it -v /宿主机目录:/容器内目录 centos /bin/bash

查看是否挂载成功

docker inspect 容器ID

如果出现Permission denied异常的话,添加-privileged=true

使用dockerfile添加

在root下创建一个docker文件夹

进入docker文件夹创建文件名为Dockerfile的文件

编写Dockerfile文件

#基于tomcat:8.5构造一个镜像
FROM tomcat:8.5
#加入容器卷
VOLUME ["/usr/local/tomcat/webapps"]
CMD echo "finished,--------success1"
CMD /bin/bash

使用Dockerfile生成自定义镜像

docker build -t mytomcat02:1.0 .

生成一个镜像 在运行

可以使用docker inspect 容器ID 查看容器卷

Dockerfile详解[一]

什么是Dockerfile

1.Dockerfile是用来构建Docker镜像的构建文件,是有一系列的命令和参数构成的脚本

2.Dockerfile的构建步骤

​ 编写dockerfile文件

​ docker build 生成新的镜像

​ docker run 运行镜像

3.以centos的镜像为例来说明 https://hub.docker.com/_/centos

DockerFile构建过程解析

2.1 基础知识

1.每条保留字指令都必须为大写字母后面要跟随至少一个从参数
2.指令从上到下顺序执行
3.# 表示注释
4.每条指令都会创建一个新的镜像层,并对镜像进行提交

2.2 大致流程

1.docker从基础镜像运行一个容器
2.执行一条指令并对容器进行修改
3.执行类似于docker commit的操作提交一个新的镜像
4.docker在基于刚提交的新的镜像运行一个新的容器
5.执行dockerfile的下一个指令再从执行第2点直到没有指令

2.3 总结

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，
*  Dockerfile是软件的原材料
*  Docker镜像是软件的交付品
*  Docker容器则可以认为是软件的运行态。
Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

1 Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。
    Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、
    服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
2 Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，
    当运行 Docker镜像时，会真正开始提供服务;
3 Docker容器，容器是直接提供服务的。

DockerFile体系结构

命令	说明
FROM	基础镜像，当前新镜像是基于哪个镜像的
MAINTAINER	镜像维护者的姓名和邮箱地址
RUN	容器构建时需要运行的命令
EXPOSE	当前容器对外暴露的端口
WORKDIR	指定在创建容器后，终端默认登陆进来的工作目录
ENV	用来在构建镜像过程中设置环境变量
ADD	将宿主机目录下的文件拷贝进镜像并且ADD命令会自动处理URL和解压tar包
COPY	类似ADD，拷贝文件和目录到镜像中 ，语法COPY src dest COPY [’'src",“dest”]
VOLUME	容器数据卷，用于数据保存和持久化工作
CMD	指定一个容器启动时要运行的命令格式 shell: CMD <命令> exec CMD [‘可执行文件’,“参数1”,“参数2”] DockerFile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换
ENTEYPOINT	指定一个容器启动时要运行的命令 ENTRYPOINT的目地和CMD一样，都是在指定容器启动程序及参数
OBBUILD	当构建一个被继承的Dockerfile时运行命令，父镜像在被子镜像继承后触发父镜像的onbuild

Dockerfile详解[二]

1. Base镜像的说明

docker Hub上99%的镜像都是通过base镜像中安装和配置需要的软件构建出来的

2. 自定义mycentos镜像

2.1目的

1.登陆后的默认路径

2.vim编辑器

3.查看网络配置ifconfig支持

2.2 进入mydocker目录创建Dockerfile文件编写

cd /mydocker
touch Dockerfile
vi Dockerfile

向Dockerfile里面写入内容

#继承父镜像
FROM centos
#作者和邮箱
MAINTAINER laolei<78414842@qq.com>
#设置环境变量
ENV MYPATH /usr/local
WORKDIR $MYPATH
#安装vim -y 代表所有的确认的地方全部yes 和网络工具
RUN yum -y install vim
# RUN yum -y install net-tools
#对外暴露的端口[提示作用]
EXPOSE 80
#输出
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

2.3 使用docker build命令构建镜像

# docker build -t 镜像名:镜像版本号 .代表当前目录(必不可少)
docker build -t mycentos:1.2 .

2.4 使用docker run命令运行

docker run -it mycentos:1.2

2.5 列出镜像的变更历史

docker history 镜像名:TAG

Dockerfile详解[三]

CMD说明

Dockerfile中可以有多个CMD的命令,但只有最后一个生效,CMD会被docker run之后的参数替换过

ENTRYPOINT说明

使用ENTRYPOINT来运行命令,在run运行的参数会追加到新的命令后面

自定义ls镜像来说明CMD和ENTRYPOINT的区别

Dockerfile详解[四]

方案选择

基于一个openjdk 不用配置java环境变量

基于一个centos 要配置java的环境变量

基于一个centos创建一个tomcat镜像

准备工作

创建目录

下载jdk

下载tomcat

创建并编写Dockerfile文件

#基于centos镜像
FROM centos
#设置作者和邮箱
MAINTAINER laolei<78414842@qq.com>
#声明变量
ENV MYPATH /usr/local/tomcat
#创建tomcat的目录
RUN mkdir -p /usr/local/java
#把tomcat和JDKcopy到/root/
ADD jdk-8u181-linux-x64.tar.gz /root/
ADD apache-tomcat-8.5.43.tar.gz /root/
#列出root目录下的所有内容
RUN ls -lh /root/
#把apache-tomcat-8.5.43修改成tomcat
RUN mv /root/apache-tomcat-8.5.43  /root/tomcat
#把tomcat 放到/usr/local/
RUN mv /root/tomcat /usr/local/
#把jdk1.8.0_181移动到/usr/local/java
RUN mv /root/jdk1.8.0_181   /usr/local/java
#设置工作目录
WORKDIR $MYPATH
#配置JAVA和tomcat环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_181
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/tomcat
ENV CATALINA_BASE /usr/local/tomcat
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#安装VIM   -y代表所有的确认的地方全部yes
#RUN yum -y install vim
#设置对名暴露的端口  纯提示作用
EXPOSE 8080  
#打开一个终端
CMD bin/startup.sh && tail -F logs/catalina.out

构造镜像

docker build -t mytomcat:1.2 .

运行镜像测试

docker run -d -p 8080:8080 mytomcat:1.2

Dockerfile详解[五]

使用jar包做项目镜像

1.准备jar包(将java项目打成jar包)

2.在linux里面创建一个目录

mkdir /root/dockerfile/myjarproject

3.上传jar包到linux的目录

4.创建并编写Dockerfole文件

#基于openjdk的镜像
FROM openjdk:8u181-jdk-alpine
#声明工作区
ENV WORKPATH /app
WORKDIR $WORKPATH
#把之前文件所在目录的bjsxt.jar添加到里面并改成app.jar
ADD bjsxt.har app.jar
#添加容器卷
VOLUME $WORKPATH
EXPOSE 8080
#使用java -jar app.jar去运行
ENTRYPOINT ["java","-jar","app.jar"]

5.构造镜像

docker build -t myjarproject:1.0 .

6.使用镜像运行容器测试

docker run -d -p 8080:8080 myjarproject:1.0

使用war包做项目镜像

1.准备war包

2.在linux里面创建一个目录

mkdir /root/dockerfile/mywarproject 

3.上传war包到linux的目录

4.创建并编写Dockerfile文件

5.构造镜像

docker build -t myjarproject:1.0 .

6.使用镜像运行容器测试

docker run -d -p 8080:8080 mywarproject:1.0

本地镜像发布到阿里云

1.镜像的生成方法

1.docker commit

2.Dockerfile

2.本地镜像推送到阿里云

2.1以修改的myjar的image为例来说明

2.2登录阿里开发平台

https://dev.aliyun.com/search.html 完成登陆

打开https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

2.3创建镜像仓库

2.4设置镜像仓库的访问密码

2.5打开阿里云镜像仓库管理页面

#登录阿里云Docker Registry
sudo docker login --username=赵斌瑞021 registry.cn-hangzhou.aliyuncs.com
#从Registry中拉取镜像
sudo docker pull registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]
#将镜像推送到Registry
sudo docker login --username=赵斌瑞021 registry.cn-hangzhou.aliyuncs.com
sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]
sudo docker push registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]

kerfile

2.本地镜像推送到阿里云

2.1以修改的myjar的image为例来说明

2.2登录阿里开发平台

https://dev.aliyun.com/search.html 完成登陆

打开https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

2.3创建镜像仓库

[外链图片转存中…(img-8VTAE3Ny-1608711842834)]

[外链图片转存中…(img-4A7N4ThJ-1608711842835)]

2.4设置镜像仓库的访问密码

[外链图片转存中…(img-pPCFyICK-1608711842835)]

2.5打开阿里云镜像仓库管理页面

[外链图片转存中…(img-ysgGAkRy-1608711842836)]

#登录阿里云Docker Registry
sudo docker login --username=赵斌瑞021 registry.cn-hangzhou.aliyuncs.com
#从Registry中拉取镜像
sudo docker pull registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]
#将镜像推送到Registry
sudo docker login --username=赵斌瑞021 registry.cn-hangzhou.aliyuncs.com
sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]
sudo docker push registry.cn-hangzhou.aliyuncs.com/myjar_zbr/myjar:[镜像版本号]