Docker安装以及使用，镜像、容器基本使用

docker概念

通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用用户的APP及其运行环境能够做到“一次镜像，处处运行”，将应用打成镜像，通过镜像成为运行在docker容器上面的示例，docker容器在任何操作系统上都是一致的，从而实现跨平台、跨服务。

一句话总结，docker是解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

传统虚拟机技术与容器虚拟化技术

虚拟机：带环境安装的一种解决方案。在主操作系统上安装的一个虚拟机管理系统（如在windows上安装VMWare），创建虚拟机（包括各种硬件），在虚拟机上安装从操作系统，在从操作系统中安装部署各种应用。对于windows底层系统来说，虚拟机就是一个普通文件，不需要了就删除。 慢、资源占用多

容器：将软件运行所需要的资源打包到一个隔离的容器中。应用进程直接运行于宿主的内核，容器内没有自己的内核且没有进行硬件虚拟。每个容器之间相互隔离，容器之间进程不会相互影响。轻量级、启动速度快、占用体积小

容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面上实现虚拟化。

docker安装网站

docker下载：https://www.docker.com

安装docker镜像的仓库：https://hub.docker.com

安装docker的前提条件

docker运行在CentOS 7上，要求系统为64位、Linux系统内核版本为3.8以上。

cat /etc/redhat-release uname -r

docker容器部署

docker本身是一个容器运行载体或称之为管理引擎。把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是镜像文件。通过这个镜像文件才能生成docker容器实例。从而实现项目的部署。镜像文件可以看作是容器的模板。docker根据镜像文件生成容器的实例。同一个镜像文件可以生成多个同时运行的容器实例。

docker的三个概念

Image（镜像）

一个只读模板。镜像可以用来创建docker容器，一个镜像可以创建很多容器。docker镜像文件类似于java的类模板，docker容器实例类似于java中new出来的实例对象。

Container（容器）

容器类似于一个虚拟化的运行环境，是用镜像创建的运行实例。容器为镜像提供了一个标准的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的。创建容器时会自动执行镜像自带的一些指令，从而实现该应用的运行。

Repository（仓库）

用来存储镜像的地方。

把docker镜像通过push命令推送到docker仓库，就可以在任何能使用docker命令的地方通过pull命令把这个镜像拉取下来。

docker安装（CentOS7）

官网：

https://docs.docker.com/engine/install/centos/

安装docker的前提条件

1、docker运行在CentOS7上，要求系统为64位、Linux系统内核版本为3.8以上。

cat /etc/redhat-release uname -r

2、卸载旧版本，清除系统残余（如果服务器之前没有装过docker，可以直接跳过此步骤）

sudo yum remove docker

3、yum安装gcc相关（确保环境能访问外网）

yum -y install gcc yum -y install gcc-c++

4、安装需要的软件包

yum install -y yum-utils

5、设置stable镜像仓库

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

6、更新yum缓存

sudo yum makecache fast

如果觉得占用磁盘空间，可以使用 yum clean 指令清除缓存：【 yum clean all 】

安装docker

7、安装docker-ce

yum -y install docker-ce docker-ce-li containerd.io

8、启动docker

sudo systemctl start docker #验证docker是否安装成功 docker info docker run hello-world

开机启动docker

sudo systemctl enable docker

9、卸载docker服务

systemctl stop docker yum remove docker-ce docker-ce-cli containerd.io rm -rf /var/lib/docker rm -rf /var/lib/containerd

10.镜像加速

mkdir /etc/docker/daemon.json

输入内容：

{

         "registry-mirrors": ["https://e4k4ovut.mirror.aliyuncs.com"],

         "log-driver":"json-file",

         "log-opts": {"max-size":"500m", "max-file":"4"}

}

systemctl daemon-reload

systemctl restart docker

docker安装（Ubuntu）

1、卸载旧版本

sudo apt-get remove docker docker-engine docker.io containerd runc

2、获取软件最新源

sudo apt-get update sudo apt upgrade

3、安装apt依赖包

sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

4、安装GPG证书

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -

5、验证

sudo apt-key fingerprint 0EBFCD88

6、设置稳定版仓库

sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

7、安装docker

sudo apt-get install docker-ce docker-ce-cli containerd.io

8、启动docker

systemctl start docker

9、测试

sudo docker run hello-world

阿里云镜像加速

加速器链接获取：

阿里云-容器-容器镜像服务-镜像工具-镜像加速器

开启加速：

mkdir -p /etc/docker

###registry-mirrors中的加速器链接需要自己获取

tee /etc/docker/deamon.json <<- 'EOF'

{

        "registry-mirrors": ["https://e4k4ovut.mirror.aliyuncs.com"]

}

EOF

systemctl daemon-reload

systemctl restart docker

docker-帮助启动类命令

启动docker

systemctl start docker

停止docker

systemctl stop docker

重启docker

systemctl restart docker

查看docker状态

systemctl status docker

开机启动

systemctl enable docker

查看docker概要信息

docker info

查看docker总体帮助

docker --help

查看docker命令帮助

docker 具体命令 --help

docker-镜像命令

创建镜像

在当前目录下使用Dockerfile脚本创建一个镜像，并把这个镜像标记为v1

docker build -t 镜像名:v1 .

也可以在根目录下建立一个build.sh的shell脚本来执行这个命令

vim build.sh docker build -t 镜像名:v1 .

本地镜像管理

1、查看镜像

#列出本地所有镜像

docker images

docker images -a #列出本地所有镜像（含历史映像层）

docker images -q #只显示镜像id

2、删除镜像

#删除镜像

docker rmi 镜像名

docker rmi -f 镜像id #强制删除

docker rmi -f $(docker images -qa) #删除所有镜像

3、镜像重命名

#将镜像1重新标记为镜像2

docker tag 镜像1:v1 镜像2:v2

4、查看镜像创建历史

docker history 镜像1

5、镜像归档

# 将镜像registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn保存成 sinn_v1.tar 归档文件

docker save -o sinn_v1.tar registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn

docker save -o 归档文件 镜像1

6、基于归档文件创建镜像

docker import 归档文件 新镜像:tag

远程仓库镜像管理

1、登录远程镜像仓库: docker login 用户信息 仓库地址

# 登录到官方Docker Hub仓库

docker login -u 用户名 -p 密码

# 登录到阿里云docker仓库

docker login --username=用户名 registry.cn-hangzhou.aliyuncs.com

2、拉取镜像：docker pull 镜像

docker pull registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1

3、推送镜像: docker push 镜像

docker push registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1

4、搜索镜像: docker search 镜像名

# 从官方Docker Hub仓库搜索node镜像

docker search node

镜像的使用

镜像通过docker run命令使用的，这是关于容器部分的操作。

# 指定使用registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1镜像创建并启动容器

docker run --name sinn-server -p 8080:8080 registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1

列出本地主机上的镜像

docker images

docker images -a #列出本地所有镜像（含历史映像层）

docker images -q #只显示镜像id

查询某镜像（是否存在）

docker search 镜像名字

docker search --limit 5 镜像名字 #只列点赞最多的5个

下载镜像，TAG为版本，不写时默认最新版

docker pull 镜像名字[:TAG]

查看镜像/容器/数据卷所占的空间

docker system df

删除镜像

docker rmi 镜像id

docker rmi -f 镜像id #强制删除

docker rmi -f $(docker images -qa) #删除所有镜像

虚悬镜像：仓库名、标签都是\的镜像，俗称虚悬镜像dangling image

docker-容器命令

容器的创建和启动

通过docker run命令即可实现容器的创建，并也会启动容器，这个命令实际上就包含了创建和启动容器两部分工作。

#新建+启动容器（前台交互式）

docker run -it --name [容器名] [镜像名] /bin/bash

#后台守护式启动容器

docker run -d 镜像名

--name="容器名"

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

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

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

-P：随机端口映射，大写P

-p：指定端口映射，小写p

对于mysql、redis等只需要后台做服务器的，建议后台守护式启动

为了方便操作，可以把命令写在一个shell脚本里面，这样只需要执行shell脚本即可，不需要每次都手动输入

# release-sinn.sh

docker run --name sinn-server -p 8888:8888 -d -e 'NODE_ENV=production' --restart=always registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1

# --name sinn-server 指定容器名为sinn-server

# -p 8888:8888 指定宿主机8888端口与容器内的8888端口形成映射

# -d 守护进程运行

# -e 'NODE_ENV=production' 设置环境变量NODE_ENV为production

# --restart=always 开机自启动

# registry.cn-hangzhou.aliyuncs.com/sessionboy/sinn:v1 指定的镜像

容器的管理

1、查看容器: docker ps

# 列出所有正在运行的容器

docker ps

2、启动已停止的容器: docker start

# 启动一个或多少已经被停止的容器

docker start [options] [containers]

3、停止容器：docker stop

# 停止正在运行的容器

sinn-server docker stop sinn-server

#强制停止容器

docker kill ID/容器名

4、重启容器：docker restart

# 重启正在运行的名称为sinn-server的容器

docker restart sinn-server

5、删除容器： docker rm

#删除容器 sinn-server

docker rm sinn-server

#若容器未停止则需要 -f强制删除

注意：删除容器命令是docker rm ，删除镜像命令是docker rmi

6、进入容器: docker exec

这个命令比较重要，因为通常我们需要进入容器内去操作一些东西。

docker exec -it 容器名称/ID 终端

# 例子: 进入ID为0d15561b9f10的容器

docker exec -it sinn-server bash

或

docker exec -it 0d15561b9f10 /bin/bash

注意： 进入容器后，如果想退出容器，只需要输入exit命令执行即可。

7、查看容器日志：docker logs

# 查看容器sinn-server的日志

docker logs sinn-server

8、容器与主机之间的数据拷贝：docker cp

# 将主机的/data/user目录拷贝到容器sinn-server内的/data/user目录

docker cp /data/user sinn-server:/data/user

# 将容器sinn-server内的/data/user目录拷贝到主机的/data/user目录

docker cp sinn-server:/data/user /data/user

9、查看容器内运行的进程

docker ps ID

10、查看容器内部细节

docker inspect ID

11、进入正在运行的容器并以命令行交互

exec进入，是在容器中打开新的终端，并启动新的进程，exit退出时容器不会停止，因此工作中常使用exec

docker exec -it ID/容器名 /bin/bash

attach进入，是直接进入容器启动命令的终端，不会启动新的进程，exit退出时容器会停止

docker attach ID

12、退出容器

exit         #run进去容器，exit退出，容器停止

ctrl+p+q         #run进去容器，ctrl+p+q，容器不停止

13、导入和导出容器

export导出容器的内容留作为一个tar归档文件

docker export ID > 文件名.tar

import从tar包中的内容创建一个新的文件系统再导入为镜像

cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号

docker容器数据卷

卷就是目录或文件，存在于一个或多个容器中，由docker挂载都容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此docker 不会在容器删除时删除其挂载的数据卷。

docker容器的数据以容器卷的方式完成数据的持久化，通过映射，将容器内的数据备份，持久化到本地主机目录。也就是说：将docker容器内的数据保存进宿主机的磁盘中。

容器卷的特点：

1、数据卷可在容器之间共享或重用数据

2、卷中的更改可以直接实时生效

3、数据卷中的更改不会包含在镜像的更新中

4、数据卷的生命周期一直持续到没有容器使用它为止

宿主vs容器之间映射添加容器卷

#直接命令添加

docker run -it --privileged -v /宿主机绝对路径目录:/容器内目录[:rw] 镜像名         #rw:容器内可读写(默认)，若只读则为ro

#查看数据卷是否挂载成功

docker inspect 容器ID

卷的继承和共享-容器2继承容器1的卷规则

docker run -it --privileged -v /mydocker/u:/tmp/u --name u1 /bin/bash docker run -it --privileged=true --volumes-from u1 --name u2 ubuntu

docker安装常用软件

安装Tomcat

#docker hub上查找tomcat镜像

docker search tomcat

#从docker hub上拉取tomcat镜像到本地

docker pull tomcat

#查看是否有拉取到的tomcat

docker images tomcat

#使用tomcat镜像创建容器实例

docker run -d -p 8080:8080 --name t1 tomcat

#新版本tomcat可能会无法直接在网页看到“猫”，需要修改文件名

rm -f webapps

mv webapps.dist webapps

#因此可以下载旧版tomcat：

docker pull billygoo/tomcat8-jdk8

安装MySQL

#在docker仓库中搜索一下MySQL

docker search mysql #

安装MySQL

docker pull mysql:8.0

docker pull mysql //默认拉取最新版本

#查看本地仓库镜像是否下载成功

docker images mysql:8.0

#创建并运行MySQL8.0容器

docker run -p 3307:3306 --name mysql8.0 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:8.0（简单版，实际使用中不可用）

docker run -d -p 3306:3306 --privileged=true

-v /home/cwm/mysql/log:/var/log/mysql

-v /home/cwm/mysql/data:/var/lib/mysql

-v /home/cwm/mysql/conf:/etc/mysql/conf.d

-e MYSQL_ROOT_PASSWORD=123456

--name mysql mysql:8.0

#解决中文乱码问题

cd /home/cwm/mysql/conf

vim my.cnf

#插入

[client]

default_character_set=utf8

[mysqld]

collation_server = utf8_general_ci

character_set_server = utf8

# 重启容器

docker restart mysql

#查看mysql8.0容器运行情况

docker ps

#docker登录mysql

docker exec -it mysql8.0 /bin/bash

#连接数据库

mysql -uroot -p

安装Redis

#从docker hub上拉取redis镜像到本地

docker pull redis

#redis配置文件下载地址

https://redis.io/docs/management/config/

#修改redis.conf

1.注释掉#band 127.0.0.1

2.daemonize yes改成no

3.开启redis数据持久化 appendonly yes 可选

# 在宿主机新建redis目录

mkdir -p /app/redis

# 准备模板conf文件拷贝到redis目录下

cp /myredis/redis.conf /app/redis/

cd /app/redis

#创建并运行redis容器

docker run -p 6379:6379 --name myredis --privileged=true

-v /home/cwm/redis/redis.conf:/etc/redis/redis.conf

-v /home/cwm/redis/data:/data

-d redis:6.0.8 redis-server /etc/redis/redis.conf

#验证redis连接

docker exec -it myr3 /bin.bash redis-cli

#证明docker启动使用了自己指定的配置文件，修改宿主机的redis配置文件，database改为10，docker restart myr3

select 15 会报错

安装JDK

docker pull primetoninc/jdk:1.8

#启动JAVA镜像容器

docker run -d -it --name java primetoninc/jdk:1.8

参数说明：

run：启动一个镜像容器

-d：指定容器运行于后台

-it：-i 和 -t 的缩写；

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

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

--name：第一个“java”是为容器指定了一个别名，而第二个“java”指的是下载镜像时的名称

#查看jdk是否安装成功

# 执行命令进入正在运行的容器的shell

docker exec -it java bash

# 在容器内部执行Java版本检查

java -version

docker中部署jar包运行

###创建dockerfile文件

cd /opt

mkdir dockerTest

cd dockerTest

rz demo.jar

#新建DockerFile，（本地新建 DockerFile 编辑好内容后上传）

        # jdk 是一个已有的包含 jdk 的镜像

        FROM java:8

        # 作者签名

        MAINTAINER libigtong

        #VOLUME指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp

        VOLUME /tmp

        #将jar包添加到容器中并更名为zzyy_docker.jar

        ADD docker_boot-0.0.1-SNAPSHOT.jar zzyy_docker.jar

        #运行jar包

        RUN bash -c 'touch /zzyy_docker.jar' ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]

        # 设置对外端口为 8080

        EXPOSE 8080

###生成镜像

docker build -t zzyy_docker:1.6 .

###生成并运行容器

docker run --name dockerApp -p 8080:8080 -d 28dae64bba9d

###启动容器

docker container ls docker start cc7c3a1582d0

###运行效果查看

docker attach cc7c3a1582d0

###关闭容器

docker stop cc7c3a1582d0 

Dockerfile

Dockerfile是用来构建docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构建成的脚本。Dockerfile定义了进程需要的一切东西。

基础知识：

1.每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2.指令按照从上到下，顺序执行

3.#表示注释

4.每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程

1.docker从基础镜像运行一个容器

2.执行一条指令并对容器做出修改

3.执行类似docker commit的操作提交一个新的镜像层

4.docker再基于刚提交的镜像运行一个新容器

5.执行dockerfile中的下一条指令直到所有指令都执行完成

Dockerfile常用保留字指令

FROM：基础镜像，指定一个已经存在的镜像作为模板，Dockerfile第一条必须是FROM

MAINTAINER：镜像维护者的姓名和邮箱地址

RUN：容器建构时需要运行的命令，有shell、exec格式，RUN是在docker build时运行

例：RUN yum -y install vim

EXPOSE：当前容器对外暴露出的端口

WORKDIR：指定在创建容器后，终端默认登录的进来工作目录，一个落脚点（根目录）

USER：指定该镜像以什么样的用户去执行，如果都不指定，默认是root

ENV：用来在构建镜像过程中设置环境变量

VOLUME：容器数据卷，用于数据保存和持久化工作

ADD：将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包

COPY：类似ADD，拷贝文件和目录到镜像中，将从构建上下文目录中<源路径>的文件/目录复制到新的一层镜像内的<目标路径>位置

        COPY src dest

        COPY ["src","dest"]

        <src源路径>:源文件或源目录

        <dest目标路径>:容器内的指定路径，该路径不用实现建好，路径不存在的话，会自动创建

CMD：指定容器启动后要干的事情。Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换。

        CMD是在docker run时运行

        RUN是在docker build时运行

ENTRYPOINT：也是用来指定一个容器启动时要运行的命令。类似于CMD命令，但是ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当做参数送给ENTRYPOINT指令指定的程序。

Dockerfile案例

要求：centos7镜像具备vim+ifconfig+jdk8

编写：

mkdir myfile

cd myfile（该目录下已有下载好的jdk8压缩包）

        vim Dockerfile

        FROM centos

        MAINTAINER zzyy<zzyybs@126.com>

        ENV MYPATH /usr/local

        WORKDIR $MYPATH

        #安装vim编辑器

        RUN yum -y install vim

        #安装ifconfig命令查看网络IP

        RUN yum -y install net-tools

        #安装java8及lib库

        RUN yum -y install glibc.i686

        RUN mkdir /usr/local/java

        #ADD时相对路径jar，把jdk-8u171-Linux-x64.tar.gz添加到容器中，安装包必须要和Dockerfile文件在同一位置

        ADD jdk-8u171-linux-x86.tar.gz /usr/local/java

        #配置java环境变量

        ENV JAVA_HOME /usr/local/java/jdk1.8.0_171

        ENV JRE_HOME $JAVA_HOME/jre

        ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH

        ENV PATH $JAVA_HOME/bin:$PATH

        EXPOSE 80

        CMD echo $MYPATH

        CMD echo "success--------ok"

        CMD /bin/bash

构建：docker bulid -t centosjava8:1.5 .

运行：docker run -it ID /bin/bash