Docker基础

一、Docker简介

1. Docker是什么?

​ 产生背景:

  • 开发和运维之间因为环境不同而导致的矛盾(不同的操作系统、软件环境、应用配置等) DevOps
  • 集群环境下每台服务器都配置相同的环境,太麻烦
  • 解决“在我的机器上可以正常工作”的问题

​ Docker是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。
​ 阿里云、百度云等都支持Docker技术

​   官网:https://www.docker.com/
​   中文官网:http://www.docker-cn.com/

2. Docker作用

​ Docker是一种容器技术,使用Docker可以:

  • 将软件环境安装并配置好,打包成一个镜像Image,然后将该镜像发布出去(Docker仓库)
  • 其他使用者可以在仓库中下载获取这个镜像
  • 通过Docker运行这个镜像,就可以获取同样的环境(容器)

​ Docker简化了环境部署和配置,实现“一次构建,处处运行”,避免了因运行环境不一致而导致的异常

​ 可以将Docker简单的认为是一个虚拟机,可以运行各种软件环境的虚拟机,但与传统虚拟机技术有所不同

​ Docker容器技术与传统虚拟机技术的区别:

  • 传统虚拟机技术:模拟一个完整的操作系统,先虚拟出一套硬件,然后在其上安装操作系统,最后在系统上再运行应用程序
    缺点:资源占用多,启动慢
  • Docker容器技术:不是模拟一个完整的操作系统,没有进行硬件虚拟,而是对进程进行隔离,封装成容器,容器内的应用程序是直接使用宿主机的内核,且容器之间是互相隔离的,互不影响
    优点:更轻便、效率高、启动快、秒级

docker容器和虚拟机(vm)区别:

 

 

3. 基本术语

​ 术语:

  • Docker主机(Host)

    安装了Docker程序的主机,运行Docker守护进程

  • Docker镜像(Image)

    将软件环境打包好的模板,用来创建容器的,一个镜像可以创建多个容器

  • Docker容器(Container)

    运行镜像后生成的实例称为容器,每运行一次镜像就会产生一个容器,容器可以启动、停止或删除

    容器使用是沙箱机制,互相隔离,是独立是安全的

    可以把容器看作是一个简易版的Linux环境,包括用户权限、文件系统和运行的应用等

  • Docker仓库(Repository)

    用来保存镜像的,仓库中包含许多镜像,每个镜像都有不同的标签Tag

    官方仓库:https://hub.docker.com/

​三要素:Docker镜像(Image)、Docker容器(Container)、Docker仓库(Repository)
使用Docker的步骤:

1. 安装Docker
2. 从Docker仓库中下载软件对应的镜像
3. 运行这个镜像,此时会生成一个Docker容器
4. 对容器的启动/停止就是对软件的启动/停止

二、准备Linux系统

1. 安装虚拟机软件

​ VMware、VirtualBox

​ Ubuntu、RHEL、CentOS、Debian、SLES(SUSE)

2. 新建虚拟机

​ 版本:Red Hat(64-bit)

​ 网络:桥接网卡

​ 光驱:选择操作系统的iso文件

3. 安装CentOS

4. 连接Linux服务器

​ 步骤:

  1. 查看服务器ip地址、

    在虚拟机中执行ip addr

  2. 连接服务器

    在客户端中执行ssh 服务器账户@服务器地址,然后输入密码

    注:SSH是Secure Shell的缩写,用于远程登陆访问的协议

5. 基本操作

5.1 常用命令

cat /proc/cpuinfo  # 查看cpu信息
cat /proc/meminfo  # 查看内存信息
uname -r # 查看内核信息,Docker要求CentOS必须是64位,且内核是3.10及以上
sudo reboot # 重启,sudo表示以管理员root身份执行
sudo halt # 关机

5.2 安装软件

​ 使用yum,是一个基于rpm的软件包管理工具

​ 用来安装软件包,可以自动解决软件包之间的依赖关系

yum install 软件包名  # 安装
yum remove 软件包名 # 卸载

三、Docker安装

  CentOS 6.5 的内核一般都是2.6,在2.6的内核下,Docker运行会比较卡,所以一般会选择升级到更高版本,本次教程升级版本为4.4.224-1.el6.elrepo.x86_64(docker需要内核3.1以上)

1. 内核升级

首先uname -r 看看现在的内核版本号是否是3.1以下,则需要升级

1、导入public key
rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org

2、安装ELRepo到CentOS-6.5中
rpm -ivh http://www.elrepo.org/elrepo-release-6-8.el6.elrepo.noarch.rpm

3、安装 kernel-lt(lt=long-term)
yum --enablerepo=elrepo-kernel install kernel-lt -y

或者安装kernel-ml(ml=mainline)
yum --enablerepo=elrepo-kernel install kernel-ml -y

4、修改引导文件,将默认引导改为0

vi /etc/grub.conf

改为default=0

5、重启查看版本

说明:1、如果报curl: (35) SSL connect error错误

           2、执行yum update nss

2. 安装Docker

​ Docker版本:社区版CE、企业版EE

# 设置yum源
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum makecache fast

yum -y install http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
# 安装Docker-CE yum -y install docker-ce


CentOS6.5 安装Docker报错No package docker available处理
yum install epel-release
yum install docker-io
仍然报错No package docker available

继续执行:
cd /etc/yum.repos.d
sudo wget http://www.hop5.in/yum/el6/hop5.repo
yum install docker-io
 

3. 启动/停止

docker version # 查看版本
systemctl start docker # 启动
systemctl stop docker # 停止
systemctl status docker # 查看状态
systemctl restart docker  # 重启
systemctl enable docker  # 设置开机自动启动
# 验证,运行hello-world
docker run hello-world  # 下载hello-world镜像并运行

4. Docker卸载

查看已安装的包:yum list installed | grep docker

删除软件包:yum -y remove docker-io.x86_64

删除镜像/容器:rm -rf /var/lib/docker

4. 配置Docker镜像加速

​ 使用阿里云提供的镜像加速(镜像仓库),也可以使用网易云等

#阿里云平台

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

​ 步骤:

  1. 注册并登陆“阿里云的开发者平台" http://dev.aliyun.com

  2. 查看专属的加速器地址

  3. 配置自己的Docker加

         #阿里云

vi /etc/docker/daemon.json
{
     "registry-mirrors": ["https://sswv6yx0.mirror.aliyuncs.com"]
   }
systemctl daemon-reload
systemctl restart docker

           # 网易云

           {"registry-mirrors": ["http://hub-mirror.c.163.com"] }

四、Docker操作

​ 输入docker可以查看Docker的命令用法,输入docker COMMAND --help查看指定命令的详细用法

1. 镜像操作

操作命令说明
查找 docker search 关键字 可以在Docker Hub网站查看镜像的详细信息,如镜像的tag标签
抽取 docker pull 镜像名:tag :tag表示软件的版本,如果不指定默认是latest
列表 docker images 查看所有本地镜像
获取元信息 docker inspect 镜像id 获取镜像的元信息,详细信息
删除

docker rmi -f 镜像id或镜像名:tag

docker rmi -f $(dockeer images -qa) 删除全部

删除指定的本地镜像,-f表示强制删除
镜像设置标签
docker tag 860c279d2fec runoob/centos:dev

docker tag 镜像ID,这里是 860c279d2fec ,用户名称、

镜像源名(repository name)和新的标签名(tag)

查看版本
docker version
 

显示镜像的摘要信息

显示镜像完整要信息

docker images --digests

docker images --no-trunc

 

2. 容器操作

操作命令说明
运行

docker run --name 容器名 -i -t -p 主机端口:容器端口 -d -v 主机目录:容器目录:ro 镜像id或镜像名称:tag

例如:

docker run \
--name mynginx \
-p 80:80 -p 443:443 \
-v /my/nginx/nginx.conf:/etc/nginx/nginx.conf \
-v /my/nginx/html:/usr/share/nginx/html:ro \
-v /etc/nginx/conf.d:/usr/nginx/conf.d \
-d nginx

--name 指定容器名,名称自定义,如果不指定会自动命名;

-i 以交互模式运行,即以交互模式运行容器;

-t 分配一个伪终端,即命令行,通常组合使用-it ;

-p 指定端口映射,将主机端口映射到容器内的端口;

-d 表示后台运行,即守护式运行容器;

-v 指定挂载主机目录到容器目录,默认为rw读写模式,ro表示只读

列表 docker ps -a -q 查看正在运行的容器,-a表示显示所有容器,-q表示只显示容器id
启动 docker start 容器id或容器名称 启动容器
停止 docker stop 容器id或容器名称 停止正在运行的容器
删除 docker rm -f 容器id或容器名称 删除容器,-f表示强制删除
日志

docker logs 容器id或容器名称

docker logs -f --tail 容器id

1、获取容器的日志

2、参数说明:

-t 是加入时间戳   -f 跟随最新的日志打印

--tail 数字 显示最后多少条

在容器中执行

docker exec -it 容器id或容器名称 /bin/bash

docker attach   容器id或容器名称

1、进入正在运行的容器中并开启一个交互模式的终端,可以在容器中执行操作

2、如果不指定会自动命名; -i 以交互模式运行,即以交互模式运行容器;-t 分配一个伪终端,即命令行,通常组合使用-it 

3、区别:exec:容器中打开的终端,并且可以启动新的进程

             attach:直接进入容器启动命令的终端,不启动新的进程

拷贝文件

docker cp 主机中的文件路径 容器id或容器名称:容器路径;

docker cp 容器id或容器名称:容器中的文件路径 主机路径

列如:

docker cp index.jsp 70cba924861c:/usr/local/tomcat/webapps/ROOT  


# 将宿主机中的文件拷贝到
将文件中的文件拷贝到容器中;将容器中的文件拷贝到主机中
获取容器内部元细节信息 docker inspect 容器id 获取容器的元信息
查看容器内运行的进程 docker top  容器id  
清理掉所有处于终止状态的容器 docker container prune  

以CentOS为例:

docker search centos
docker pull centos
docker run --name mycentos -it centos:latest  # 根据centos:latest镜像运行容器,并以交互模式进入容器中
# 实际上是在Docker容器中运行一个精简版的CentOS系统 
exit # 退出并关闭容器
docker ps -a
docker start mycentos
docker stop mycentos
docker rm mycentos
docker rm -f $(docker ps -aq)  # 强制删除所有容器
docker exec -i -t mycentos /bin/bash 进入镜像

​ 注:Docker容器内实际上是运行着一个精简版的Linux系统

以tomcat为例:

# 示例1:基本用法
docker search tomcat
docker pull tomcat
docker run --name mytomcat -p 8888:8080 -d tomcat 
# 测试:http://宿主机地址:8888
docker stop mytomcat
docker ps -a
docker start mytomcat

# 示例2:拷贝文件和挂载目录
docker run -p 8080:8080 -d tomcat
docker exec -it 70cba924861c  /bin/bash
cd /usr/local/tomcat/webapps/ROOT
exit
echo welcome to tomcat > index.jsp
docker cp index.jsp 70cba924861c:/usr/local/tomcat/webapps/ROOT  # 将宿主机中的文件拷贝到容器中指定的目录中
# 部署web项目,将war文件放到容器中
docker cp spring-web.war 70cba924861c:/usr/local/tomcat/webapps

# 问题:如果项目更改了需要重新拷贝war文件,太麻烦,可以直接挂载目录(也称为数据卷Volume)
docker run \
-p 8080:8080 \
-v /my/tomcat/webapps/spring-web.war:/usr/local/tomcat/webapps/spring-web.war \
-v /my/tomcat/data:/usr/local/tomcat/dataVolume:ro \
-d tomcat

# 示例3:启动多个容器,一个镜像可以启动多个容器,互相隔离、独立
docker run -p 8081:8080 -d tomcat
docker run -p 8082:8080 -d tomcat
docker run -p 8083:8080 -d tomcat

3. 镜像的分层结构

​ tomcat镜像为什么这么大?

​ 镜像是一种轻量级、可执行的独立软件包,用来打包软件运行环境和基于运行环境的软件,包含运行某个软件所需要的所有内容。

​ 基于UnionFS联合文件系统,采用分层结构,一层一层的堆叠起来,像一个同心圆,但从外面来说,只能看到最外层的文件系统(镜像层)

分层结构:共享资源、便于复用(许多镜像都是从相同的Base基础镜像构建而来的,基础镜像只需要保存一份)

​ 镜像都是只读的,而由镜像生成的容器是可修改的

4. 创建镜像

​ 有时从Docker镜像仓库中下载的镜像不能满足我们的要求,此时可以基于这个镜像(基础镜像)封装一个自己的镜像

​ 两种方式:

  • 更新镜像:使用docker commit命令
  • 构建镜像:使用docker build命令,需要创建Dockerfile文件

4.1 更新镜像

​ 先使用基础镜像创建一个容器,然后对容器进行修改,最后使用commit命令提交为一个新的镜像

​ 步骤:

  1. 根据基础镜像,创建容器

    docker run --name mytomcat -p 8080:8080 -d tomcat
  2. 修改容器

    docker exec -it bcd08edac78d  /bin/bash
    cd webapps/ROOT
    rm -f index.jsp
    echo welcome to tomcat > index.html
    exit
  3. 提交为新镜像,语法:docker commit -m="描述消息" -a="作者" 容器id或容器名 镜像名:tag

    docker commit -m="修改默认索引页" -a="汤小洋" bcd08edac78d itany/tomcat:v1
  4. 使用新镜像运行容器

    docker run --name tomcat_v1 -p:8080:8080 -d itany/tomcat:v1

4.2 构建镜像

​ 根据Dockerfile文件来自动构建镜像

​ Dockerfile是一个包含创建镜像所有命令的文本文件,使用docker build命令可以根据Dockerfile的内容创建镜像

​ 步骤:

  1. 创建一个Dockerfile文件vi Dockerfile

    # 基础镜像
    FROM tomcat
    
    # 作者
    MAINTAINER tangxiaoyang@itany.com
    
    # 执行命令
    RUN rm -f /usr/local/tomcat/webapps/ROOT/index.jsp
    RUN echo "welcome to tomcat!" > /usr/local/tomcat/webapps/ROOT/index.html
  2. 构建新镜像,语法:docker build -f Dockerfile文件的路径 -t 镜像名:tag 命令执行的上下文

    docker build -f Dockerfile -t itany/tomcat:v2 .
  3. 使用新镜像运行容器

    docker run -p 9999:8080 -d itany/tomcat:v2

5.导出和导入容器

5 .1导出容器

如果要导出本地某个容器,可以使用 docker export 命令。

$ docker export 1e560fca3906 > centos.tar

5 .2 导入容器快照

可以使用 docker import 从容器快照文件中再导入为镜像,以下实例将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1:

$ cat docker/ubuntu.tar | docker import - test/ubuntu:v1

也可以通过指定 URL 或者某个目录来导入,例如:

$ docker import http://example.com/exampleimage.tgz example/imagerepo

五、Docker容器数据卷

1、Docker容器数据卷概念

docker容器数据卷是什么?

  • 将运用与运行的环境打包形成容器运行 ,运行可以伴随着容器,但是我们对数据的要求希望是持久化的
  • 容器之间希望有可能共享数据

Docker容器产生的数据,如果不通过docker commit生成新的镜像,使得数据做为镜像的一部分保存下来,
那么当容器删除后,数据自然也就没有了。
为了能保存数据在docker中我们使用卷。
能干什么
卷就是目录或文件,存在于一个或多个容器中,由docker挂载到容器,但不属于联合文件系统,因此能够绕过Union File System提供一些用于持续存储或共享数据的特性:
卷的设计目的就是数据的持久化,完全独立于容器的生存周期,因此Docker不会在容器删除时删除其挂载的数据卷
特点:
1:数据卷可在容器之间共享或重用数据
2:卷中的更改可以直接生效
3:数据卷中的更改不会包含在镜像的更新中
4:数据卷的生命周期一直持续到没有容器使用它为止

docker容器数据卷作用:

  • 容器的持久化
  • 容器间继承+共享数据
2、命令添加Docker容器数据卷

命令:
docker run --name 容器名 -i -t -p 主机端口:容器端口 -d -v 主机目录:容器目录:ro 镜像id或镜像名称:tag

说明:-v 指定挂载主机目录到容器目录,默认为rw读写模式,ro表示只读
2.1 命令添加
centos镜像添加为例,执行:
 docker run --name yhw/centos -it -d -v 主机目录:容器目录 镜像id或镜像名称:tag

说明:1、
Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
2、解决办法:在挂载目录后多加一个--privileged=true参数即可
2.2 查看数据卷是否挂载成功
docker inspect 容器ID
2.3 命令带权限
docker run --name yhwcentos -it -d -v 主机目录:容器目录:ro 镜像id或镜像名称:tag

 

3、Dockerfile添加容器数据卷

       根据Dockerfile文件来自动构建镜像

       ​Dockerfile是一个包含创建镜像所有命令的文本文件,使用docker build命令可以根据Dockerfile的内容创建镜像

 

       3.1.可在dockerfile中使用volume指令来给镜像添加一个或多个数据卷

VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
说明:
出于可移植和分享的考虑,用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
由于宿主机目录是依赖于特定宿主机的,并不能够保证在所有的宿主机上都存在这样的特定目录。

3.2  file构建

#volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo “finished,--------success1”
CMD /bin/bash

       3.3 build后生成镜像

构建新镜像,语法:docker build -f Dockerfile文件的路径 -t 镜像名:tag 命令执行的上下文

4、数据卷容器

概念:命名的容器挂载数据卷,其它容器通过挂载这个(父容器)实现数据共享,挂载数据卷的容器,称之为数据卷容器
4.1 容器间传递共享(--volumes-from)
命令:docker run -it --name 子容器名 --volumes-from 父容器名
镜像id或镜像名称:tag
第一步,先启动父容器centos1.0

   第二步,再启动子容器centos2.0,继承父容器centos1.0

 第三步,验证数据是共享

 结论:容器之间配置信息的传递,数据卷的生命周期一直持续到没有容器使用为止

六、Dockerfile详解

1. 简介

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

​ Dockerfile从FROM命令开始,紧接着各种命令、参数等,最终会生成一个新的镜像

​ 使用Dockerfile构建镜像的步骤:

  1. 编写Dockerfile文件
  2. 使用docker build构建镜像
  3. 使用docker run运行容器

2. 用法

2.1 语法规则

  • 指令必须要大写,且后面必须跟参数
  • 第一条指令必须是FROM,指定Base Image 基础镜像
  • 指令按从上往下的顺序,依次执行
  • 每条指定都会创建一个新的镜像层并提交
  • #表示注释

2.3 docker执行dockerfile的流程

  • docekr从基础镜像运行一个容器
  • 执行一条指令并对容器做出修改
  • 执行类似docker commint的操作提交一个新的镜像层
  • docker再基于刚提交的镜像运行一个新容器
  • 执行dockerfile中的下一条指令直到所有指令都执行完

2.3 常用指令

指令解释
FROM 指定基础镜像,即当前新镜像是基于哪个镜像的
MAINTAINER 指定镜像作者命名和邮箱地址
RUN 指定构建过程中要运行的命令
ENV 用来在构建镜像过程中设置环境变量
WORKDIR 指定默认的工作目录,即进入容器后默认进入的目录,一个落脚点
VOLUME 创建挂载点,也称容器数据卷,用于数据共享和持久化
CMD

指定容器启动时要运行的命令,与RUN不同的是,这些命令不是在镜像构建过程中执行的

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

ENTRYPOINT

指定一个容器启动时要运行的命令 ENTRYPOINT和CMD一样,都是指定容器启动程序和参数

COPY

类似ADD 拷贝文件和目录到镜像中,

将从构建上下文目录中<源文件>的文件/目录复制到新的一层镜像内的<目标路径>位置 COPY src dest 或COPY [“src”,“dest”]

ADD 将宿主机目录下的文件拷贝文件到镜像中,且ADD命令会自动处理URL和自动解压tar压缩包
EXPOSE 指定对外暴露的端口
ONBUILD 当构建一个被继承的dockerfile时运行命令,父镜像在被子继承后父镜像的onbuild被触发

构建新镜像语法

语法:docker build -f Dockerfile文件的路径 -t 镜像名:tag 命令执行的上下文

3. 案例

3.1 自定义centos镜像

# 1.编写Dockerfile文件
vi Dockerfile2
    FROM centos

    MAINTAINER tangxiaoyang@itany.com

    ENV MYPATH /usr/local/centos
    RUN mkdir -p $MYPATH
    WORKDIR $MYPATH

    RUN yum -y install vim

    RUN yum -y install wget

    # 创建挂载点,无法指定宿主机上对应的目录,是自动生成的
    VOLUME  ["/data1","/data2"]

    CMD ["/bin/bash"]
# 2.使用docker build构建镜像
docker build -f Dockerfile2 -t itany/centos:v1 . 
# 3.使用docker run运行容器
docker run -it b25b1dad795c
# 查看镜像的变更历史
docker history b25b1dad795c
# 验证挂载点:
/var/lib/docker/volumes/0b001b4cc8db1ebbbb4c537c17a5c44adb700fb0e1b941bc82cc717c4ae196f6/_data
/var/lib/docker/volumes/f020f5a5664bf68312be9f49a640f27ecfb49990b231aaf3d0eb7cb723fa0ddd/_data

3.2 自定义tomcat镜像

# 准备工作 

# 1.编写Dockerfile文件
vi Dockerfile
    FROM centos
    MAINTAINER tangxiaoyang@itany.com
    
# 把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下 # 拷贝文件,文件必须与Dockerfile在同一目录下 COPY teacher.txt /usr/local

#把java与tomcat添加到容器中 ADD jdk-8u171-linux-x64.tar.gz /usr/local ADD apache-tomcat-8.5.30.tar.gz /usr/local # 配置java和tomcat环境变量 ENV JAVA_HOME /usr/local/jdk1.8.0_171 ENV CLASSPATH .:$JAVA_HOME/lib ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.30 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin
##设置工作访问时候的WORKDIR路径,登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
   #WORKDIR $CATALINA_HOME 

RUN yum -y install vim #容器运行时监听的端口 EXPOSE 8080
        #启动时运行tomcat
       # ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
       # CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
       #CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache
   CMD ["catalina.sh", "run"]
# 2.使用docker build构建镜像 docker build -t itany/tomcat:1.0 . # 3.使用docker run运行容器 docker run \ --name mytomcat \ -p 8080:8080 \ -v /my/tomcat/webapps/spring-web.war:/usr/local/apache-tomcat-8.5.30/webapps/spring-web.war \ -d itany/tomcat:1.0

 3.3 CMD和ENTRYPOINT的区别

  • CMD

    在Dockerfile中可以有多个CMD指令,但只有最后一条指令生效,所以一般只有一条CMD指令

    CMD指令在被docker run之后的参数覆盖

    vi aaa
    FROM centos
    CMD ["/bin/ls"]
    CMD ["/bin/bash"]
    docker build -f aaa -t itany/aaa . 
    docker run -it itany/aaa
    docker run -it itany/aaa /bin/pwd
  • ENTRYPOINT

    docker run之后的参数会被作为ENTRYPOINT指令的参数,组合形成新的命令

    vi bbb
    FROM centos
    ENTRYPOINT ["/bin/ls","/usr/local"]
    docker build -f bbb -t itany/bbb .
    docker run -it itany/bbb
    docker run -it itany/bbb -l  #  ls /usr/local -l

案例:

FROM cenos 

RUN yum install -y curl

CMD [ "curl", "-s", "http://ip.cn" ]

命令:docker build -f Dockerfile -t myip .

 

 

 

FROM cenos 

RUN yum install -y curl

ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]

命令:docker build -f Dockerfile -t myip .

3.4 ONBUILD应用

 

七、使用Docker搭建环境

1. 安装MySQL

# 1.拉取镜像
docker pull mysql:5.7
# 2.运行容器
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7
docker exec -it mysql /bin/bash
find / -name "*mysql*"
exit
# 3.创建用于挂载的目录
mkdir -p /my/mysql/conf # 挂载配置文件
mkdir -p /my/mysql/data # 挂载数据文件
mkdir -p /my/mysql/logs # 挂载日志文件
# 4.拷贝配置文件并修改
docker cp mysql:/etc/mysql/mysql.conf.d/mysqld.cnf /my/mysql/conf/
vi /my/mysql/conf/mysqld.conf
    character-set-server=utf8
# 5.重新运行容器  
docker rm -f mysql  # 删除原来的容器
docker run \
--name mysql \
-p 3306:3306 \
-v /my/mysql/conf:/etc/mysql/mysql.conf.d/ \
-v /my/mysql/data:/var/lib/mysql \
-v /my/mysql/logs:/logs \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

说明:\:是连接符 # 6.访问 # 本地访问 docker exec -it mysql /bin/bash mysql -u root -p # 远程访问 mysql -u root -p -h 宿主机地址
#7.备份
docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"123456" ' > /yhw/all-databases.sql

2. 安装Redis

# 1.拉取镜像
docker pull redis
# 2.创建用于挂载的目录
mkdir -p /my/redis/conf 
mkdir -p /my/redis/data
# 3.拷贝配置文件并修改
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
tar zxf redis-4.0.10.tar.gz
cp redis.conf /my/redis/conf/
vi redis.conf
    requirepass itany
    appendonly yes
# 4.运行容器
docker run \
--name myredis \
-p 6379:6379 \
-v /my/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
-v /my/redis/data:/data \
-d redis redis-server /usr/local/etc/redis/redis.conf
# 5.访问
# 本地访问
docker exec -it myredis /bin/bash
redis-cli
# 远程访问
使用RedisDesktopManager工具连接

3. 安装Nginx

# 1.拉取镜像
docker pull nginx
# 2.运行容器
docker run --name mynginx -p 80:80 -d nginx
# 3.创建用于挂载的目录
mkdir -p /my/nginx  # 挂载nginx所有数据
mkdir -p /my/nginx/html # 挂载nginx虚拟主机(网站html数据)
# 4.拷贝配置文件
docker cp mynginx:/etc/nginx/nginx.conf /my/nginx  # 拷贝主配置文件
docker cp mynginx:/etc/nginx/conf.d /my/nginx # 拷贝虚拟主机配置文件
echo welcome to nginx > /my/nginx/html/index.html # 自定义索引页
# 5.重启运行容器
docker rm -f mynginx
docker run \
--name mynginx \
-p 80:80 -p 443:443 \
-v /my/nginx/nginx.conf:/etc/nginx/nginx.conf \
-v /my/nginx/html:/usr/share/nginx/html:ro \
-v /etc/nginx/conf.d:/usr/nginx/conf.d \
-d nginx
# 6.测试
http://宿主机地址

七、将本地镜像发布到阿里云

​ 步骤:

  1. 登陆“阿里云-开发者平台”,创建命名空间和镜像仓

  2. https://cr.console.aliyun.com/repository/cn-chengdu/ml_yhw/mycentos_yhw1.0.1/details
  3. 将镜像推送到阿里云

    # 登陆阿里云的docker仓库
    docker login --username=tangyang8942@163.com registry.cn-hangzhou.aliyuncs.com
    # 创建指定镜像的tag,归入某个仓库
    docker tag b25b1dad795c registry.cn-hangzhou.aliyuncs.com/itany/centos:v1.0
    # 将镜像推送到仓库中
    docker push registry.cn-hangzhou.aliyuncs.com/itany/centos:v1.0
  4. 拉取镜像

    docker pull registry.cn-hangzhou.aliyuncs.com/itany/centos:v1.0

posted on 2020-05-21 16:41  uestc2007  阅读(29)  评论(0编辑  收藏

导航