目录
一:Docker是什么?
Docker利用容器独立运行一个或一组应用。容器是用镜像创建的运行实例。
它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。
可以把容器看作是一个简易版的linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。
容器的定义和镜像几乎一模一样,也是一堆层的统一视角,唯一区别在于容器的最上面那一层是可读可写的。
仓库(repository):
仓库是集中存放镜像文件的场所。
仓库和仓库注册服务器(registry)是有区别的。仓库注册服务器上往往存放着多个仓库,每个仓库中又包含了多个镜像,每个镜像有不同的标签(tag)。
仓库分为公开仓库和私有仓库两种形式。
最大的公开仓库是Docker Hub(https://hub.docker.com/)
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云(https://dev.aliyun.com/search.html)、网易云(https://c.163yun.com/hub#/m/home/)等。
Docker本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境,这个打包好的运行环境就似乎image镜像文件。只有通过这个镜像才能生存Docker容器。image文件可以看作是容器的模板。docker根据image文件生成容器的实例。同一个image文件,可以生成多个同时运行的容器实例。
image文件生成的容器实例,本身也是一个文件,称之为镜像文件。
一个容器运行一种服务当我们需要的适合,就可以通过docker客户端创建一个对应的运行实例,也就是我们的容器。
至于仓库,就是放了一堆镜像的地方,我们可以把镜像发布到仓库中,需要的时候从仓库中拉下来就可以了。
centos6.8
1.yum install -y epel-release(类似Java中的jdbc驱动包)
2.yum install -y docker-io
3.安装后的配置文件:/etc/sysconfig/docker
4.启动docker后台服务:service docker start
5.docker version验证
centos7
https://docs.docker.com/install/linux/docker-ce/centos
中文网:https://www.docker-cn.com
阿里云镜像加速:
是什么:https://dev.aliyun.com/search.html
注册一个属于自己的的阿里云账户
获得加速器地址连接
配置本机docker运行镜像加速器
重新启动docker后台服务 service docker restart
linux系统下配置完加速器需要检查是否生效
https://s02zwcoe.mirror.aliyuncs.com
{
"registry-mirrors": "https://s02zwcoe.mirror.aliyuncs.com"
}
常用命令:
docker version
docker info
docker --help
鲸鱼背上有集装箱
蓝色的大海里面-------宿主系统windows10
鲸鱼 ----docker
集装箱 ---- 容器实例 form 来自我们能用的镜像模板
docker images
options说明
-a:列出本地所有的镜像(含中间镜像层)
-q:只显示镜像ID.
--digests:显示镜像的摘要信息
--no-trunc:显示完整的镜像信息
docker search 某个xxx镜像的名字
网站: https://hub.docker.com
命令:
options:说明
--no-trunc:显示完整的镜像描述
-s:列出收藏数不小于指定值的镜像
--automated:只列出automated build类型的镜像;
docker search -s 30 tomcat
docker pull 某个xxx镜像名字
下载镜像
docker pull tomcat 等价于 docker pull tomcat:lastest
docker rmi 某个镜像名字id
docker rmi -f(强制删除) hello-world:latest
options:说明
[root@localhost /]# docker rmi -f hello-world nginx:latest
[root@localhost /]# docker rmi -f $(docker images -qa)
二:容器
有镜像才能创建容器,这是根本前提(下载一个centos镜像演示,[root@localhost /]# docker pull centos)
新建并启动容器 docker run[options] image [command][arg]
options说明(常用):有些是一个减号,有些是两个减号
--name="容器新名字":为容器制定一个名称:
-d:后台运行容器,并返回容器ID,也即启动守护式容器:
-i:以交互模式运行容器,通常与-t同时使用:
-t:为容器重新分配一个伪输入终端,通常与-i同时使用:
-P:随机端口映射
-p:制定端口映射,有一下四种格式
ip:hostPort:containerPort
ip:containerPort
hostPort:containerPort
containerPort
列出所有当前正在运行的容器
ps -ef:查看所有进程
docker ps:查看所有集装箱
options说明(常用):
-a:列出当前所有正在运行的容器+历史上运行过的
-l:显示最近创建的容器
-n:显示最近n个创建的容器
-q:静默模式,只显示容器编号
--no-trunc:不截断输出
退出容器:
两种退出方式:
exit 容器停止、退出
ctrl+P+Q 容器不停止退出
启动容器:
docker start 容器id或者容器名
重启容器:
docker restart 容器id或者容器名
停止容器:
docker stop 容器id或者容器名
强制停止:
docker kill 容器id或者容器名
删除已停止的容器:
docker rm 容器id
一次性删除多个容器
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm
重要:
启动守护式进程 docker run -d 容器名
问题:使用docker ps -a将进行查看,会发现容器已经退出
很重要的要说明的一点:docker容器后台运行,就必须有一个前台进程
容器运行的命令如果不是那些一直过期的命令(比如运行top,tail),就是会自动退出的。
这个是docker的机制问题,比如你的web容器,我们以nginx为例,正常情况下,我们配置启动服务只需要启动相应的service即可。例如service nginx start
但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,这样的容器后台启动后,会立即自杀因为他就的没事可做了,所以,最佳的方案是,将你要运行的程序以前台进程的形式运行。
查看可能容器日志:
docker logs -f -t --tail 容器id
-t 是加入时间戳
-f 跟随最新的日志打印
--tail 数字显示最后多少条
docker run -d centos /bin/sh -c "while true;do echo hello zzyy;sleep 2;done"
查看容器内运行的进程
docker top 容器id
查看容器内部细节
docker inspect 容器id
进入正在运行的容器并以命令行交互
docker exec -it 容器id /bin/bash
重新进入docker attach 容器id
上述两个区别:
attach:直接进入容器自动命令的终端,不会启动新的进程
exec:是在容器中打开新的终端,并且可以启动新的进程
docker run -it centos
docker run -it image /bin/bash(默认)
从容器内拷贝文件到主机上:
docker cp 容器id:容器内路径 目的主机路径
[root@localhost /]# docker cp f27586d32b9f:/tmp/yum.log /root
三:镜像
4.docker镜像
镜像是一种轻量级、可执行的独立软件包,用来打包软件运行 环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码、运行时、库、环境变量和配置文件。
是什么:
UnionFS(联合文件系统)
Docker镜像加载原理
分层的镜像
为什么tomcat400多兆?
因为:(tomcat(jdk8(centos(kernel))))
为什么docker镜像要采用这种分层结构呢
最大的一个好处就是-共享资源
比如:有多个镜像都从相同的base镜像构建而来,那么宿主机只需在磁盘上保存一份base镜像。同时内存中也只需加载一份base镜像,就可以未所有容器服务了。而且镜像的每一层都可以被共享。
特点:docker镜像都是只读的,当容器启动时,一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”,“容器层”之下的都叫“镜像层”。
docker镜像commit操作补充
docker commit提交容器副本使之成为一个新的镜像
docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[标签名]
案例演示:
1.从hub上下载tomcat镜像到本地并成功运行
docker run -it -p 8080:8080 tomcat
[root@localhost conf]# docker run -it -p 8888:8080 tomcat
-p:主机端口:docker容器端口
-P 随机分配端口
i:交互
t:终端
2.故意删除上一步镜像生产tomcat容器的文档
root@5a8b2743ef45:/usr/local/tomcat/webapps# rm -rf docs/
3.也即当前的tomcat运行实例是一个没有文档内容的容器,以它的模板commit一个没有doc的tomcat新镜像atguigu/tomcat02
docker commit -a="liyinlong" -m="tomcat without docs" 容器id atguigu/mytomcat:1.2
[root@localhost /]# docker commit -a="liyinlong" -m="tomcat without docs" 5a8b2743ef45 atguigu/mytomcat:1.2
删除所有容器:
[root@localhost /]# docker rm -f $(docker ps -q)
4.启动我们的镜像并和原来的对比
[root@localhost /]# docker run -it -p 7777:8080 atguigu/mytomcat:1.2
后台启动:
[root@localhost /]# docker run -it -p 7788:8080 tomcat
前台启动:
[root@localhost /]# docker run -d -p 7788:8080 tomcat
四:容器数据卷
5.Docker容器数据卷
是什么?
一句话:有点类似我们redis里面的rdb和aof文件
可以做什么?
容器的持久化
容器间继承+共享数据
数据卷
卷就是目录或文件,存在于一个或多个容器中,有docker挂载到容器,但不属于联合文件系统,因此能够绕过Union File System提供一些用于持续存储或共享数据的特性:
卷的设计目的就是数据的持久化,完全独立于容器的生存周期,因此Docker不会再容器删除时删除其挂载的数据卷。
特点:
1:数据卷可在容器之间共享或重用数据
2:卷中的更改可以直接生效
3:数据卷中的更改不会包含再镜像的更新中
4:数据卷的生命周期一直持续到没有容器使用它为止。
容器内添加:
直接命令添加
命令:
docker run -it -v /宿主机绝对路径:/容器内目录 镜像名
docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名
docker run -it -v /myDataVolume:/dataVolumeContainer 镜像名
docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
ro:read only
容器仅允许读取,不允许写入,允许 主机读取和写入。
[root@localhost /]# docker inspect 4ba0ed330ea4
DockerFile添加:
dockerfile是什么?
javaEE Hello.java ---> Hello.class
Docker images ===> DockerFile; t
查看数据卷是否 挂载成功:
容器和宿主机之间数据共享:
容器停止退出后,主机修改后数据是否同步:
命令(带权限):
DockerFile:
是什么?
java Hello.java ---> Hello.class
docker images ====> DockerFile
https://hub.docker.com
是镜像模板的描述文件
根目录下新建mydocker文件夹并进入
可在dockerfile中使用volume指令来给镜像添加一个或多个数据卷
File构建
build后生成镜像 获得一个新镜像liyinlong/centos
run容器
通过上述步骤,容器内的卷目录地址已经知道
对应的主机目录地址在哪?
主机对应默认地址
VOLUME ["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
说明:处于可抑制和分享的考虑,用-v 主机目录:容器目录这种方法不能够直接在dockerfile中实现。
由于宿主机目录是依赖与特定宿主机的,并不能够保证在所有的宿主机上都存在这样的特定目录。
# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,----------success1"
CMD /bin/bash
docker run -it -v /host1:/dataVolumeContainer1 -v /host2:/dataVolumeContainer2 centos /bin/bash
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile -t liyinlong/centos .
docker run -it liyinlong/centos
Docker挂载主机目录Docker访问出现cannot open direcotry .:Persion denied
解决办法:在挂载目录后多加一个--privileged=true参数即可。
备注:
数据卷容器
命名的容器挂载数据卷,其它容器通过挂载这个(父容器)实现数据共享,挂载数据卷的容器,称之为数据卷容器。
以上一步新建的镜像liyilong/centos为模板并运行容器dc01/dc02/dc03
它们已经具有容器卷
/dataVolumeContainer1
/dataVolumeContainer2
容器间传递共享(--volumes-from)
先启动一个父rongqidc01
在dataVolumeContainer2新增内容
命令
docker run -it --name dc01 liyinlong/centos
[root@6d9a7c77330d dataVolumeContainer2]# touch dc01_add.txt
ctrl+p+q
dc02/dc03继承自dc01
docker run -it --name dc02 --volumes-from dc01 liyinlong/centos
touch dc02_add.txt
docker run -it --name dc03 --volumes-from dc01 liyinlong/centos
删除dc01,dc02修改后dc03可否访问
删除dc02后dc03可否访问
新建dc04继承dc03后再删除dc03
docker run -it --name dc04 --volumes-from dc03 liyinlong/centos
结论:容器之间配置信息的传递,数据卷的生命周期一直持续到没有容器使用它为止。
--volumes-from
dc02/dc03分别在dataVolumeContainer2各自新增内容
五:DockerFile
6.dockerFile解析
是什么
dockerfile内容基础知识:
a.每条保留字指令都必须为大写字母且后面要跟随至少一个参数
b.指令从上到下,顺序执行
c.#表示注释
d.每条指令都会创建一个新的镜像层,并对镜像进行提交
回顾:
1.手动编写一个dockerfile文件,当然,必须要符合file的规范
2.有这个文件后,直接docker build命令执行,获得一个
自定义的镜像
3.run
maven build
jar
java -jar ext...
dockerfile是用来构建docker镜像的构建文件,是由一系列命令和参数构成的脚本
构建三步骤
1)编写dockerfile文件
2)docker build
3)docker run
文件什么样???
以我们熟悉的centos为例
FROM scratch(所有镜像的祖先类:本源镜像,基础镜像:元镜像)
MAINTAINER(作者、邮箱) The CentOS Project <cloud-ops@centos.org>
ADD c68-docker.tar.xz /
LABEL name="CentOS Base Image" \
vendor="CentOS" \
license="GPLv2" \
build-date="2016-06-02"
# Default command
CMD ["/bin/bash"]
docker run -it centos -->CMD ["/bin/bash"]
class Book{
private int id;
public Book(){
}
{
System.out.print();
}
static{
}
}
dockerfile构建过程解析
docker执行dockerfile的大致流程
1)docker从基础镜像运行一个容器
2)执行一条指令并对容器做出修改
3)执行类似docker commit的操作提交一个新的镜像层
4)docker再基于刚提交的镜像运行一个新容器
5)执行 dockerfile中的下一条指令直到所有指令都执行完成
dockerfile体系结构(保留字指令)
FROM
基础镜像,当前新镜像是基于哪个镜像的
MAINTAINER
镜像维护者的姓名和邮箱地址
RUN
容器构建时需要运行的命令
EXPOSE
当前容器对外暴露出的端口
WORKDIR
指定在创建容器后,终端默认登陆进来的工作目录,一个落脚点
ENV
用来在构建镜像过程中设置环境变量
例如:ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用,这就如同在命令前面指定了环境变量前缀一样;也可以在其他指令中直接使用这些环境变量;
比如:WORKDIR $MY_PATH
ADD
将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY
类似ADD,拷贝文件和目录到镜像中。将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
COPY src dest
COPY["src","dest"]
VOLUME
容器数据卷,用户数据保存和持久化工作
CMD
指定一个容器启动时要运行的命令;
Dockerfile中可以有多个CMD命令,但只有最后一个生效,CMD会被docker run之后的参数替换
CMD容器启动命令
cmd指令的格式和run相似,也是两种格式:
shell 格式:CMD<命令>
exec 格式:CMD["可执行文件","参数1","参数2"...]
参数列表格式:CMD["参数1","参数2",...],在指定了ENTRYPOINT指令后,用CMD指定具体的参数。
ENTRYPOINT
指定一个容器启动时要运行的命令
ENTRYPOINT的目的和CMD一样,都是在指定容器启动程序及参数。
ONBUILD
当构建一个被继承的dockerfile时运行命令,父镜像在被子继承后父镜像的onbuild被出发
案例
Base镜像(scratch):
docker hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的
自定义镜像mycentos:
1).编写:
Hub默认centos镜像什么情况
准备编写dockerfile文件
mycentos内容dockerfile
FROM centos
ENV mypath /tmp
WORKDIR $mypath
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD /bin/bash
======================
FROM centos
MAINTAINER liyinlong<18312884980@163.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 87
CMD echo $MYPATH
CMD echo "success---------------ok"
CMD /bin/bash
2).构建
docker build -t 新镜像名字:TAG.(.表示当前目录)
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile2 -t mycentos:1.3 .
3).运行
4).列出镜像的变更历史
[root@localhost /]# docker history 5182e96772bf
CMD/ENTRYPOINT镜像案例:
都是指定一个容器启动时要运行的命令
CMD:
Dockerfile中可以有多个cmd命令,但只有最后一个生效,cmd会被docker run之后的参数替换!
[root@localhost /]# docker run -it -p 7777:8080 tomcat ls -l
执行此命令,tomcat不会启动!!!
Case:tomcat的讲解演示
Dockerfile里面是最后
CMD ["catalina.sh","run"]
ENTRYPOINT:
docker run之后的参数会被当做参数传递给ENTRYPOINT,之后形成新的命令组合。
Case:
制作CMD版可以查询IP信息的容器
FROM centos
RUN yum install -y curl
CMD ["curl","-s","http://ip.cn"]
[root@localhost mydocker]# dcoker build -f /mydocker/Dockerfile3 -t myip .
[root@localhost mydocker]# docker run -it myip
当前 IP:119.137.52.31 来自:广东省深圳市 电信
问题:如果我们希望显示HTTP头信息,就需要加上-i参数
[root@localhost mydocker]# curl -s -i http://ip.cn
HTTP/1.1 200 OK
Date: Fri, 07 Sep 2018 03:28:31 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=d94e004a4e5bec5ff1df5dc0912b94a601536290911; expires=Sat, 07-Sep-19 03:28:31 GMT; path=/; domain=.ip.cn; HttpOnly
Server: cloudflare
CF-RAY: 456615f7c1945420-LAX
当前 IP:119.137.52.31 来自:广东省深圳市 电信
WHY
制作ENTROYPOINT版查询IP信息的容器
FROM centos
RUN yum install -y curl
ENTRYPOINT ["curl","-s","http://ip.cn"]
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile4 -t myip2 .
[root@localhost mydocker]# docker run -it myip2 -i
HTTP/1.1 200 OK
Date: Fri, 07 Sep 2018 03:34:01 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=df3f9160681e3384fa388f4a72031a2a51536291241; expires=Sat, 07-Sep-19 03:34:01 GMT; path=/; domain=.ip.cn; HttpOnly
Server: cloudflare
CF-RAY: 45661e00e45378e0-LAX
curl http://www.baidu.com(获取网页源代码)
ONBUILD:
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile4 -t my_father .
Dockerfile5
FROM my_father
RUN yum install -y curl
CMD ["curl","-s","http://ip.cn"]
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile5 -t my_son .
Sending build context to Docker daemon 6.144kB
Step 1/3 : FROM my_father
# Executing 1 build trigger
---> Running in 1f0d719e1181
father image onbuild---------886
Removing intermediate container 1f0d719e1181
---> 933adadb2304
Step 2/3 : RUN yum install -y curl
---> Running in d0492d89d9a7
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
* base: mirrors.huaweicloud.com
* extras: mirrors.aliyun.com
* updates: mirrors.aliyun.com
Package curl-7.29.0-46.el7.x86_64 already installed and latest version
Nothing to do
Removing intermediate container d0492d89d9a7
---> 6f0cfe4eb39c
Step 3/3 : CMD ["curl","-s","http://ip.cn"]
---> Running in 80036c4f893c
Removing intermediate container 80036c4f893c
---> 98e4f43e4976
Successfully built 98e4f43e4976
Successfully tagged my_son:latest
六:自定义镜像tomcat9
1.mkdir -p /liyinlong/mydockerfile/tomcat9
2.在上述目录下touch c.txt
3.将jdk和tomcat安装的压缩包拷贝进上一步目录
apache-tomcat-9.0.8.tar.gz
jdk-8u171-linux-x64.tar.gz
4.在/liyinlong/mydockerfile/tomcat9目录下新建dockerfile文件
内容:
FROM centos
MAINTAINER liyinlong<18312884980@163.com>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u181-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.11.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径,登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_181
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.11
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.11
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.11/bin/startup.sh"]
# CMD ["/usr/local/apache-tomcat-9.0.11/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.11/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.11/bin/logs/catalina.out
5.构建
[root@localhost tomcat9]# docker build -t liyinlongtomcat9 .
-f指定dockerfile文件,若名称为Dockerfile,则不需要加-f
6.run
docker run -d -p 9080:8080 --name myt9 -v /liyinlong/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.11/webapps/test -v /liyinlong/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.11/logs --privileged=true liyinlongtomcat9
分步讲解:
docker run -d(后台运行) -p 9080:8080 --name myt9
-v(添加容器卷) /liyinlong/mydockerfile/tomcat9/test:
/usr/local/apache-tomcat-9.0.11/webapps/test
-v(添加容器卷) /liyinlong/mydockerfile/tomcat9/tomcat9logs/:
/usr/local/apache-tomcat-9.0.11/logs
--privileged=true
liyinlongtomcat9
7.验证
浏览器打开:http://192.168.17.132:9080/
[root@localhost /]# docker exec f38d823eec6a ls -l
total 8
drwxr-xr-x. 9 root root 4096 Sep 7 07:12 apache-tomcat-9.0.11
drwxr-xr-x. 2 root root 6 Apr 11 04:59 bin
-rw-r--r--. 1 root root 0 Sep 7 06:32 cincontainer.txt
drwxr-xr-x. 2 root root 6 Apr 11 04:59 etc
drwxr-xr-x. 2 root root 6 Apr 11 04:59 games
drwxr-xr-x. 2 root root 6 Apr 11 04:59 include
drwxr-xr-x. 7 10 143 4096 Jul 7 08:09 jdk1.8.0_181
drwxr-xr-x. 2 root root 6 Apr 11 04:59 lib
drwxr-xr-x. 2 root root 6 Apr 11 04:59 lib64
drwxr-xr-x. 2 root root 6 Apr 11 04:59 libexec
drwxr-xr-x. 2 root root 6 Apr 11 04:59 sbin
drwxr-xr-x. 5 root root 49 Aug 4 22:04 share
drwxr-xr-x. 2 root root 6 Apr 11 04:59 src
8.结合前述的容器将测试的web服务test发布
docker exec -it containerID /bin/bash
小总结:
见有道云笔记
7.Docker常用安装
总体步骤:
搜索镜像、拉取镜像、查看镜像、启动镜像、停止容器、移除容器
安装tomcat:
a).docker hub上面查找tomcat镜像
docker search tomcat
b).从docker hub上拉去tomcat镜像到本地
docker pull tomcat
c).docker images查看是否有拉取到的tomcat
docker images tomcat
d).使用tomcat镜像创建容器(也叫运行镜像)
docker run -it -p 8080:8080 tomcat
-p:主机端口:docker容器端口
-P:随机分配端口
-i:交互
-t:终端
安装MySQL:
a).docker hub上面查找mysql镜像
docker search mysql
b).从docker hub上(阿里云加速器)拉取镜像到本地标签为5.6
docker pull mysql:5.6
c).使用mysql5.6镜像创建容器(也叫运行镜像)
docker run -p 12345:3306 --name mysql -v /liyinlong/mysql/conf:/etc/mysql/conf.d -v /liyinlong/mysql/logs:/logs -v /liyinlong/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6
命令说明:
-p 12345:3306 将主机的12345端口映射到docker容器的3306端口
--name mysql:运行服务名字
-v /liyinlong/mysql/conf:/etc/mysql/conf.d:将主机/liyinlong/mysql目录下的conf/my.cnf挂载到容器的/etc/mysql/conf.d
-v /liyinlong/mysql/logs:/logs:将主机/liyinlong/mysql目录下的logs目录挂载到容器的/logs
-v /liyinlong/mysql/data:/var/lib/mysql:将主机/liyinlong/mysql目录下的data目录挂载到容器的/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456:初始化root用户的密码
-d mysql5.6:后台程序运行mysql5.6
docker exec -it MySQL运行成功后的容器ID /bin/bash
数据备份:
docker exec mysql服务器ID sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /liyinlong/all-databases.sql
安装redis:
1.拉取镜像
[root@localhost /]# docker pull redis:3.2
2.镜像创建容器(也叫运行镜像)
docker run -p 6379:6379 -v /liyinlong/myredis/data:/data -v /liyinlong/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes
docker run -p 6379:6379
-v /liyinlong/myredis/data:/data
-v /liyinlong/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf
-d(后台运行) redis:3.2 redis-server /usr/local/etc/redis/redis.conf
--appendonly(开启aof) yes
3.在主机/liyinlong/myredis/conf/redis.conf目录下新建redis.conf文件
vim /liyinlong/myredis/conf/redis.conf/redis.conf
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
supervised no
pidfile /var/run/redis_6379.pid
测试redis-cli连接上来
docker exec -it 容器id redis-cli
测试持久化文件生成
[root@localhost data]# vi /liyinlong/myredis/data/appendonly.aof
8.本地镜像发布到阿里云
本地镜像发布到阿里云流程:
镜像的生成方法:
a).前面的Dockerfile
b).从容器创建一个新的镜像
docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]
-a:提交的镜像作者:
-m:提交时的说明文字:
将本地镜像推送到阿里云:
1.运行一个实例
[root@localhost data]# docker run -it mycentos:1.3
2.生成一个新的镜像并commit
[root@localhost data]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
36a6d4d97ff7 mycentos:1.3 "/bin/sh -c /bin/bash" 33 seconds ago Up 31 seconds 87/tcp mystifying_murdock
[root@localhost data]# docker commit -a liyinlong -m "new mycentos:1.4 with vim and ifconfig" 36a6d4d97ff7 mycentos:1.4
sha256:bcc1767f51c0a24adcfafb3d43bf67d00d7e207401c96ee6c5c2e403c5f1d5f4
[root@localhost data]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mycentos 1.4 bcc1767f51c0 10 seconds ago 371MB
3.推送到阿里云
3.1本地镜像素材原型
3.2阿里云镜像开发者平台
https://dev.aliyun.com/search.html
3.3创建仓库镜像
3.3.1命名空间
3.3.2仓库名称
3.4将镜像推送到registry
$ sudo docker login --username=龙_1994 registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos:[镜像版本号]
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos:[镜像版本号]
registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos 1.4 bcc1767f51c0
3.5公有云可以查询到
liyinlong/mycentos
6.查看详情
将阿里云上的镜像下载到本地:
docker pull registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos
[root@localhost data]# docker run -it bcc1767f51c0