centos7更新Docker源 centos7自带docker

Docker在Centos7安装、及命令（详细安装教程）

• 为什么使用Docker
• Docker中包括三个基本概念
• Docker安装
• Docker获取镜像
• 使用刚刚获取的centos镜像，创建一个容器，在容器中运行bash应用
• Docker 创建镜像

• 编写Dockerfile文件
• 第二种
• 修改已有镜像
• 本地启动 --在容器启动 bash命令行

• 这样可以使用systemctl启动服务了。

• 仓库拉取json，在容器安装 、添加了应用
• 接着我们可以使用我们自己创建的镜像来启动容器了
• 另一个重建镜像的方式

• 首先新建一个目录和Dockerfile
• Dockerfile中输入指令，每条指令都创建一层镜像(不能超过127层)
• 然后使用docker build构建镜像：
• 现在可以使用创建好的额镜像来启动容器了
• 修改镜像的标签 tag

• Docker 本地导入镜像

• 用户通过docker push 命令，把自己创建的镜像上传到仓库中共享
• 上传镜像：把自己创建的镜像上传到仓库中共享。

• Docker 保存、载入、删除镜像

• 我们的镜像做好了之后，我们要保存起来，以供备份使用，怎么做哪？
• 我们有了本地的镜像文件，在需要的时候可以用docker load将本地保存的镜像再次导入docker中容器里面来
• 删除镜像id
• 删除容器

• 全部删除
• 只删除status=exited
• 删除 docker images

• Docker 容器的创建启动和停止

• docker容器启动有两种方式

• 基于镜像新建容器并启动
• 我们还可以通过指定参数，启动一个bash交互终端

• docker run命令启动容器，后台运行操作保护
• 将在终止状态的容器从新启动
• 终止容器
• 守护态运行(后台启动)
• 要查看启动的centos容器中的输出，可以使用
• 终止容器

• Docker命令进入容器后台 两种方式

• 1、docker attach是Docker自带的命令。

• docker exec
• docker attach

• 2、nsenter

• PID=$(docker-pid 5d1ba7f7affc)
• docker inspect

• Docker命令导入导出和删除容器

• 导出某个容器，非常简单 使用docker export命令
• 有了容器快照之后，我们可以在想要的时候随时导入
• 通过指定一个URL或者目录来导入
• 导入镜像和导入容器快到的区别
• 删除 终止状态的容器

• Docker公有仓库Docker Hub

• docker官方提供了一个工具docker-registry,我们可以借助这个工具构建私有镜像仓库
• 使用docker push上传私有仓库里面去
• 在去别一台的机子

• 数据卷和数据卷容器

• 容器中管理数据主要有两种方式:

• 数据卷
• 创建数据卷
• 还可以挂载主机目录作为数据卷
• 只读的权限
• 挂载单个文件到容器

• Docker 制作数据卷容器

• 建立数据卷容器
• 如果从其他的容器中，想从这个容器(db)的数据卷挂载数据(db1) ，应该怎么做呢
• 数据卷容器不是自动删除的，要删除数据卷，必须在删除最后一个挂着数据卷容器是指定-v参数

• Docker数据卷容器实现备份恢复及迁移

• 使用数据卷来备份数据
• 回复数据卷容器

• 创建数据卷容器

• Docker容器绑定外部端口和IP

• 首先是外部访问容器
• 使用-p（小写)则可以指定要映射的端口，并且在一个指定端口上只可以绑定一个容器，支持的格式有
• docker 默认会映射本地所有的地址。现在我们来尝试一下映射到指定地址的指定端口 访问到容器里面的web应用(python app.py)
• 然后要访问容器中的应用只能通过127.0.0.1这个ip访问。
• docker inspect
• 在启动容器的时候，可以多次使用-p标记来绑定多个端口

• Docker容器互联 容器与容器之间互联

• 容器互联：使用--link参数，可以让容器之间安全的进行交互
• 我们可以查看下web容器的环境变量

• 例子

• 第一步骤 本地有这个python镜像
• 第二步骤 首先创建Dockerfile:里面定义了我们构建镜像的指令步骤
• 第三步骤 创建镜像
• 第四步骤 启动容器
• 第五步骤 把redis装到独立容器里面
• 进入容器找到进程的编号
• 重启容器
• 成功

• Dockerfile基本结构讲解

• Dockerfile 是一个文本格式的配置文件，用户可以使用Dockerfile快速创建自定义的镜像。
• Dockerfile文件分为四个部分，下面会分别讲到

• Dockerfile中的指令

• FROM
• MAINTAINER
• RUN
• CMD
• EXPOSE
• ENV
• ADD
• COPY
• ENTRYPOINT
• VOLUME --数据卷
• USER
• WORKDIR
• ONBUILD

• /bin/bash把默认的CMD的给覆盖了
• 创建好Dockerfile之后
• docker安装python
• Docker系列

为什么使用Docker

1.与传统的虚拟化方式相比具有众多的优势。

1. Docker容器的启动在秒级 、
2. Docker对系统资源利用率高,一台主机上可以同时运行数千个Docker容器。
3. Docker基本不消耗系统资源，使得运行在Docker里面的应用的性能很高

2.相比于传统的虚拟化技术，Docker在以下几个方面具有较大的优势。

1. 更快速的支付和部署：开发者可以使用一个标准的镜像来构建一套开发容器，开发完成之后，运维人员可以直接使用 这个容器来部署代码。
2. 更高效的虚拟化：Docker 容器的运行不需要额外的 hypervisor 支持，它是内核级的虚拟化，因此可以实现更高的性 能和效。
3. 更轻松的迁移和扩展：Docker 容器几乎可以在任意的平台上运行，包括物理机、虚拟机、公有云、私有云、个人电 脑、服务器等。率。
4. 更简单的管理：使用 Docker，只需要小小的修改，就可以替代以往大量的更新工作。所有的修改都以增量的方式被分发和更新，从而实现自动化并且高效的管理

Docker中包括三个基本概念

1. 镜像（Image)
2. 容器（Container)
3. 仓库（Repository) 理解好这三个概念， 就可以了解Docker的整个生命周期。

2.镜像：是一个只读的模板，例如一个完整的Centos操作系统
镜像可以用来创建Docker容器，Docker中提供了一个很简单的方式来常见镜像和更新镜像，甚至可以从其他地方直接拷
贝已经做好的镜像直接使用。镜像有点类似于编程中的Class类，在运行的时候生成对象。

3.容器：是从镜像创建并运行的实例，就像一个启动好了的播放器程序，它可以被开始，停止，启动和删除。每个容器
都是相互隔离的，绝对保证安全。
你可以把容易看成一个启动了的Liunx简化版系统，里面包括root用户权限，进程空间，用户空间和网络空间，还包括运
行在里面的应用程序

4.仓库：是集中存放镜像文件的地方。还有一种服务叫做仓库注册服务器（可以理解为GitHub这样的托管服务器），里
面存放着多个仓库，每个仓库中又包含多个镜像，每个镜像又有不同的标签。仓库的概念有点类似于Git,也分为公有仓
库和私有仓库，全世界对打的Docker仓库是Docker Hub,国内最大的Docker仓库是Docker Pool.
用户可以在本地网络或者服务器上创建一个私有仓库，当用户创建了一个自己的镜像之后，使用push命令把镜像上传到
自己的仓库中，下次在另外一台机器上使用这个镜像的时候，只需要从仓库中pull下来就可以直接使用了

Docker安装

yum install docker

安装之后启动 Docker 服务，并让它随系统启动自动加载。

systemctl start docker.service

systemctl enable docker.service #系统启动自动加载

Docker获取镜像

镜像是一个模板，可以从镜像服务器上获取做好的镜像。docker 使用 docker pull命令来获取需要的镜像

例如我们获取一个mysql镜像。
docker pull mysql

#这个就是mysql另外的名字
docker pull mariadb

docker images #查看镜像

REPOSITORY --仓库
TAG --标签 镜像版本 标记
IMAGE_ID 每个镜像都有个镜像ID

使用刚刚获取的centos镜像，创建一个容器，在容器中运行bash应用

docker run -t -i centos /bin/bash

docker ps

-t 让容器启动之后，产生命令行

-t 让Docker分配一个伪终端并在绑定在容器的标准输入，-i让容器的标准输入保持打开

Options	Mean
-i	以交互模式运行容器，通常与 -t 同时使用；
-t	为容器重新分配一个伪输入终端，通常与 -i 同时使用；
-d	后台运行容器，并返回容器ID；

Docker 创建镜像

编写Dockerfile文件

FROM centos:7
RUN yum install -y vim

docker build -t chanmufeng/centos-vim2

第二种

修改已有镜像

docker pull training/sinatra

本地启动 --在容器启动 bash命令行

docker run -t -i training/sinatra /bin/bash
 root@f96ad1d07d7b:/# ls -al

这样可以使用systemctl启动服务了。

创建容器：

docker run -d -name centos7 --privileged=true centos:7 /usr/sbin/init

进入容器：

docker exec -it centos7 /bin/bash

这样可以使用systemctl启动服务了

仓库拉取json，在容器安装 、添加了应用

root@f96ad1d07d7b:/# gem install json

多了一个容器(json)组件，更新保存新的镜像
1、先退出容器 exit
2、Docker Container 维护者的信息
3、给镜像创建另外一个名字
4、7b789b19757d 容器的id(镜像仓库的名字)
5、sinatra镜像的名字

docker commit 将容器id 保存为新的镜像,并添加提交人信息和说明信息。

例子
docker commit -m 'add json gem' -a 'Docker Container' 7b789b19757d my/sinatra:v2

-m参数指定提交的说明注释，和Git中的git commit -m的参数是一样的；
-a指定更新的用户信息，后面是用来创建镜像的容器ID，最后是创建镜像的仓库名和tag信息。
创建成功后，命令会返回这个镜像的ID信息

[root@bogon ~]# docker commit -m 'my new image' -a '[e-mail]' f96ad1d07d7b my/sinatra:v2.0

接着我们可以使用我们自己创建的镜像来启动容器了

my/sinatra:v2.0     :v2.0是个标签

[root@bogon ~]# docker run -t -i my/sinatra:v2.0 /bin/bash

另一个重建镜像的方式

使用Dockerfile来创建镜像，使用docker commit虽然很容易扩展镜像，但不便于团队分享，我们可以使用docker,build来创建一个新的镜像，为此首先要创建一个Dockerfile文件，这个文件中包含如何创建镜像的指令

首先新建一个目录和Dockerfile

[root@bogon ~]# mkdir docker
[root@bogon ~]# cd docker/
[root@bogon docker]# mkdir centos
[root@bogon docker]# ll
总用量 0
drwxr-xr-x. 2 root root 6 6月  24 11:22 centos
[root@bogon docker]# cd centos/
[root@bogon centos]# ll
总用量 0
[root@bogon centos]# touch Dockerfile
[root@bogon centos]#

Dockerfile中输入指令，每条指令都创建一层镜像(不能超过127层)

#注解
FROM centos  #从哪一个镜像作为基础
MAINTAINER REGAN [e-mail]  #维护者基础者的信息
RUN yum -qqy install mysql --nogpgcheck  #镜像装东西的命令

解释 ：
其中 FROM 告诉Docker使用哪个镜像作为基础
接着是维护者的信息
RUN开头的指令会在创建中运行，例如安装一些软件包，这里使用yum 安装python.
注意使用yum 需要制定参数 -qqy，不然呢可能会报错的。

例子：
from centos  # 指定此dockerfile是基于哪个镜像的，至少基于scratch
 
ENV mypath /tmp  # 定义环境变量
 
WORKDIR $mypath  # 定义工作目录
 
RUN yum -y install vim  # 执行命令
RUN yum -y install net-tools
 
EXPOSE 80  # 暴露端口号
 
CMD /bin/bash  # 执行最终命令，也可以使用json字符串的形式，比如CMD ["/bin/bash"]

然后使用docker build构建镜像：

centos_with_python #镜像的名字

使用docker build 回到本地去找Dockerfile，读取Dockerfile的指令构建镜像 启动

[root@bogon centos]# docker build -t='my/centos_with_python:v1.0.1' .

如果解析到mysql，就会去相应的仓库下载相应的包来构建我们的镜像

解释

其中 -t 标记来添加 tag，指定新的镜像的用户信息。 “.” 是 Dockerfile 所在的路径（当前目录），也可以替
换为一个具体的 Dockerfile 的路径。

可以看到 build 进程在执行操作。它要做的第一件事情就是上传这个 Dockerfile 内容，因为所有的操作都要依据
Dockerfile 来进行。 然后，Dockfile 中的指令被一条一条的执行。每一步都创建了一个新的容器，在容器中执行指令并提交修改（就跟之前介绍过的 docker commit 一样）。当所有的指令都执行完毕之后，返回了最终的镜像 id。所有的中间步骤所产生的容器都被删除和清理了。

需要注意的是一个镜像是不能操作127层的，否则会报错！
当然Dockerfile中还可以输入其他的命来，例如可以使用ADD命令复制本地文件到镜像中；用EXPOSE命令对外开放端

现在可以使用创建好的额镜像来启动容器了

[root@bogon centos]# docker run -t -i 6bd2f231a436 /bin/bash

修改镜像的标签 tag

[root@bogon centos]# docker tag 6bd2f231a436 my/centos:v1.0.1

Docker 本地导入镜像

用户通过docker push 命令，把自己创建的镜像上传到仓库中共享

docker push rarlinux

本地系统的镜像文件导入到docker里面

cat rarlinux-x64-5.3.0.tar.gz | docker import - rarlinux:5.3

可以看到导入完成后，docker为我们生成了一个镜像ID，使用docker images也可以看到我们刚刚从本地导入的镜像。注意镜像文件必须是tar.gz类型的文件

上传镜像：把自己创建的镜像上传到仓库中共享。

docker push rarlinux

如果是失败，需要写账号的名字GitHub

改下标签 docker tag

Docker 保存、载入、删除镜像

我们的镜像做好了之后，我们要保存起来，以供备份使用，怎么做哪？

保存的时候必须是.tar的 压缩tar的命令

docker save 命令 保存镜像快照到本地

[root@bogon docker]# docker save -o centos.tar my/centos

我们有了本地的镜像文件，在需要的时候可以用docker load将本地保存的镜像再次导入docker中容器里面来

docker load --input rarlinux.tar.gz 
或者 
docker load < rarlinux.tar.gz

[root@bogon docker]# docker load --input centos.tar

删除镜像id

#加-f 强制所有相同id删除掉

docker rmi -f 镜像ID

同样的镜像id被多个repository依赖如何删除 还是不知道详细删除

[root@bogon docker]# docker rmi my/centos:v1.0.1
使用docker rmi repository:tag 的组合来删除特殊的镜像;

删除容器

全部删除

docker container ls -aq
docker rm $(docker container ls -aq)

只删除status=exited

docker rm $(docker container ls -f "status=exited" -q)

删除 docker images

删除none的镜像，要先删除镜像中的容器。要删除镜像中的容器，必须先停止容器。

$ docker images

$ docker rmi $(docker images | grep "none" | awk '{print $3}')
直接删除带none的镜像，直接报错了。提示先停止容器。

$ docker stop $(docker ps -a | grep "Exited" | awk '{print $1 }') //停止容器

$ docker rm $(docker ps -a | grep "Exited" | awk '{print $1 }') //删除容器

$ docker rmi $(docker images | grep "none" | awk '{print $3}') //删除镜像

Docker 容器的创建启动和停止

docker容器启动终止方式

容器是独立运行的一个或一组应用，及他们的运行环境。容器是Docker中的一个重要的概念

docker容器启动有两种方式

基于镜像新建容器并启动

docker run centos cal

我们还可以通过指定参数，启动一个bash交互终端

docker run -t -i centos /bin/bash

-i: 交互式操作。

-t: 终端。

docker run命令启动容器，后台运行操作保护

1. 检查本地是否存在指定的镜像，不存在则从公有仓库下载
2. 使用镜像创建并启动容器，简化版linux系统
3. 分配一个文件系统，并在只读的镜像层外面挂载一层可读可写层
4. 从宿主主机配置的网桥接口中桥接一个虚拟接口道容器中去
5. 从地址池分配一个ip地址给容器
6. 执行用户指定的应用程序 就会执行/bin/bash命令
7. 执行完毕之后容器被终止

将在终止状态的容器从新启动

可以使用docker start命令，直接将一个已经终止的容器启动运行起来。

docker start mysql

终止容器

[root@bogon ~]# docker stop a2cf79d323d2

守护态运行(后台启动)

很多时候，我们希望容易在后台以守护态运行，此时可以添加-d参数来实现（d是daemon的首字母）

每隔一秒中打印hello docker

docker run -d centos /bin/sh -c "while true;do echo hello docker;sleep 1;done"

要查看启动的centos容器中的输出，可以使用

docker logs cec560b7fc9c

终止容器

[root@bogon ~]# docker stop a2cf79d323d2

#查看容器

docker ps -a

docker stop

Docker命令进入容器后台 两种方式

1、docker attach是Docker自带的命令。

docker exec

docker exec：推荐大家使用 docker exec 命令，因为此退出容器终端，不会导致容器的停止

docker exec -it myCentos /bin/bash

docker attach

docker run -idt /bin/bash

docker ps

docker attach infallible_brown

这个命令是同步的操作，如果有很多的用户，启立一个容器，很多人都用docker attach去链接这个容器，如果中途有阻塞的 ，其他同事就不能通过attach

2、nsenter

nsenter命令：在util-linux包2.23版本后都有包含。nsenter可以访问另一个进程的名字空间

wget https://www.kernel.org/pub/linux/utils/util-linux/v2.24/util-linux-2.24.tar.gz;
tar -zxvf util-linux-2.24.tar.gz
cd util-linux-2.24
./configure --without-ncurses && make nsenter
cp nsenter /usr/local/bin

错误 checking for fcc …no checking for cc … no

为了链接到容器，需要知道容器的PID，可以使用nsenter获取，如下：

PID=$(docker-pid 5d1ba7f7affc)

docker-pid需要自己安装，否则找不到命令

docker-pid  3630a7301fe1

获取了PID之后，就可以通过下面的命令进入容器了
nsenter --target 5421 --mount --uts --ipc --net --pid

docker inspect

首先
#镜像生成一个容器

docker run --name redis -d redis

#启动

[root@bogon ~]# docker start redis

在可以使用docker inspect来查看该容器的详细信息。
先 docker ps
docker inspect 44fc0f0582d9
docker inspect -f {{.State.Pid}} 44fc0f0582d9

在拿到该进程PID之后我们就可以使用nsenter命令访问该容器了。

$ sudo nsenter --target 11869--mount --uts --ipc --net --pid  
$ sudo nsenter --target 11869--mount --uts --ipc --net --pid  
其中的3326即刚才拿到的进程的PID

 
 1004  [2018-10-11 15:26:44]sudo docker ps
 1005  [2018-10-11 15:27:05]sudo docker inspect sudo docker inspect sudo docker inspect
 1006  [2018-10-11 15:27:20]sudo docker inspect 572a98ee09bd
 1007  [2018-10-11 15:31:33]sudo docker inspect -f {{.State.Pid}}  572a98ee09bd
 1008  [2018-10-11 15:32:55]sudo nsenter--target 11869--mount --uts --ipc --net --pid
 1009  [2018-10-11 15:33:18]sudo nsenter --target 11869--mount --uts --ipc --net --pid

docker inspect

Docker命令导入导出和删除容器

导出某个容器，非常简单 使用docker export命令

[root@bogon ~]# docker export 3630a7301fe1 > ~/docker/centos.tar

有了容器快照之后，我们可以在想要的时候随时导入

导入快照使用docker import命令

[root@bogon docker]# cat centos.tar | docker import - my/centos:v.2.0.1 导入容器快照作为镜像

通过指定一个URL或者目录来导入

处理本地的容器快照导入为镜像，我们还可以通过指定一个URL或者目录来导入

例如在某个网络上有个快照image_test.tgz

docker import http://xxxx.com/image_test.tgz test/image_test

导入镜像和导入容器快到的区别

.docker中可以使用docker load来导入镜像，也可是使用docker import来导入一个容器快照到docker镜像。两者的区别是容器快照将丢弃所有的历史记录和元数据信息。而镜像保存完整的记录，因此要更大些

删除 终止状态的容器

容器先停止docker stop ID，在删除 docker rmi ID

docker rm 容器id

若要删除一个运行中的容器，需要加-f参数

删除所有未运行的容器（已经运行的删除不了，未运行的就一起被删除了）

sudo docker rm $(sudo docker ps -a -q)

杀死所有正在运行的容器
docker kill $(docker ps -a -q)


        删除所有已经停止的容器
docker rm $(docker ps -a -q)


        删除所有未打 dangling 标签的镜像
docker rmi $(docker images -q -f dangling=true)


         删除所有镜像
docker rmi $(docker images -q)

        强制删除镜像名称中包含“doss-api”的镜像
docker rmi --force $(docker images | grep doss-api | awk '{print $3}')

　　删除所有未使用数据

docker system prune

　　只删除未使用的volumes

docker volume prune

Docker公有仓库Docker Hub

仓库是集中存放镜像的地方。容易混淆的是注册服务器，它是管理仓库的服务器，每个服务器上可以有多个仓库，每个仓库下可以有多个镜像。因此仓库可以被认为是一个具体的目录。

例如dl.dockerpool.com/centos来说，dl.dockerpool.com是注册服务器地址，centos是仓库名字

地址/仓库的名字

需要登陆注册

docker login

#存的验证的信息

[root@bogon docker]# pwd
/etc/docker

#认证信息

[root@bogon docker]# cd ~/.docker/
[root@bogon .docker]# ls
config.json

docker官方提供了一个工具docker-registry,我们可以借助这个工具构建私有镜像仓库

使用docker search命令查找registry

[root@bogon docker]# docker search registry

docker pull registry

-p 指定端口
-v 指定路径的映射

docker run -d -p 5000:5000 -v
/root/docker/registry:/tmp/registry registry

docker默认的私有库是在容器/tmp/registry 下 ，映射到本地的目录 /root/docker/registry:/

[root@bogon docker]# docker run -d -p 5000:5000 -v /root/docker/registry:/tmp/registry registry

[root@bogon ~]# netstat -lnp | grep 5000
tcp6       0      0 :::5000                 :::*                    LISTEN      12009/docker-proxy-

解释

默认情况下，仓库会创建在容器中的/tmp/registry目录下，通过-v 指定将镜像文件存
放在本地的目录中。
d.搭建好了私有仓库之后，就可以上传、下载、搜索镜像了。

使用docker push上传私有仓库里面去

把名字 改成 本机ip/centos 用tag命令改下

docker tag 14a1b1556e64 192.xxx.xx.xx:5000/centos

[root@bogon ~]# docker push 192.xxx.xx.xx:5000/centos

报错

报错，解决方法是在/etc/docker目录下新建daemon.json,文件中写入：
{ "insecure-registries":["192.168.0.5:5000"] }
然后重启docker :systemctl restart docker
重新运行docker run -d -p 5000:5000 -v /root/docker/registry:/tmp/registry
registry，启动registry服务，再次运行docker push 192.168.0.5:5000/rarlinux上传镜像
到私有仓库。

在去别一台的机子

docker pull 192.xxx.xx.xx:5000/centos

数据卷和数据卷容器

容器中管理数据主要有两种方式:

1. 数据卷
2. 数据卷容器

数据卷

是一个可供一个或多个容器受用的特殊目录，它绕过UFS，可以提供很多有用的特性

1. 数据卷可以在容器之间共享和重用
2. 对数据卷的修改会立马生效
3. 对数据卷的更新，不会影响镜像
4. 卷会一直存在，直到没有容器使用

-v标记创建一个数据卷并且挂载到容器里。
–name指定容器的名称
-d(后台)是指守护状态下运行（daemon） 启动之后，使用docker attach命令进入守护状态运行的容器中

是在容器里面创建数据卷

创建数据卷

-it
-p
创建 /webapp 的数据卷
training/webapp 这个是镜像的名字

例子
docker run -d -P -it --name web1 -v /webapp training/webapp /bin/bash

#linux
[root@bogon ~]# docker run -d -P -it --name web2 -v /datas centos /bin/bash

进入守护进程里面

[root@bogon ~]# docker attach ce462a8df4118d6bd8f9f3d61a0501663db127cb17e7ea0a198dd69d02fa3571

还可以挂载主机目录作为数据卷

: 前是本地的目录
:后面是映射容器的目录

-d是后台
外围到容器一个映射的ip
随机生成要给端口，映射到5000端口上 (0.0.0.0 32795-> 5000/tcp)

例子
docker run -d -P -it --name web2 -v /root/docker:/opt/docker training/webapp /bin/bash

只读的权限

可以加权限限制：ro

docker run -d -P -it --name web3 -v /root/docker:/opt/docker:ro training/webapp /bin/bash

挂载单个文件到容器

[root@bogon ~]# head .bash_history 挂载容器怎么做

例子:
docker run -d -P -it --name web4 -v ~/.bash_history:/.bash_history training/webapp /bin/bash

[root@bogon ~]# docker run -d -P -it --privileged=true --name name9 -v /root/.bash_history:/koo:ro centos /bin/bash
[root@64eb4b98417d /]# cat koo

Docker 制作数据卷容器

是一个正常的容器，专门用来提供数据卷供其他容器挂载 —共其它容器挂载

建立数据卷容器

创建一个database 一个容器，名字叫db

[root@bogon ~]# docker run -d -v /database --name db centos echo database

[root@bogon ~]# docker logs db
database

如果从其他的容器中，想从这个容器(db)的数据卷挂载数据(db1) ，应该怎么做呢

例子
docker run -d --volumes-from db --name db1 -it training/postgres

[root@bogon ~]# docker run -d -it --volumes-from db --name db1 -it centos /bin/bash

数据卷容器不是自动删除的，要删除数据卷，必须在删除最后一个挂着数据卷容器是指定-v参数

docker rm -v 数据卷的名字

Docker数据卷容器实现备份恢复及迁移

使用数据卷来备份数据

通过指定本地的一个文件路径，对应到容器中的路径，运行tar命令将重要的文件打包备份。

db 来自卷容器的
-v $(pwd) 是当前目录 挂载到容器的docker目录
:/nihao 挂载到容器的nihao 目录上

[root@bogon docker]# pwd
/root/docker
[root@bogon docker]# docker run --privileged=true  --volumes-from db -v $(pwd):/nihao --name db13 -it centos /bin/bash

卷容器的目录 database

挂载的目录 nihao

[root@56a87c5f214d nihao]# tar cvf registry.tar /database/

在退出，去本地地址

回复数据卷容器

创建数据卷容器

数据卷容器，在和本地目录挂载到 ，同一个卷容器中 进行操纵

要将数据恢复到数据卷容器，首先要创建一个带有数据卷的容器db10

docker run -d -it -v /db10 --name database2 centos /bin/bash

然后创建另外一个容器名字叫db11，挂载database2容器，只有使用tar xvf解压文件到挂载的容器卷中。

[root@bogon docker]# docker run --privileged=true -it -d --name db17 --volumes-from database2  -v $(pwd):/docker centos /bin/bash

[root@bogon docker]# docker attach 75f4190d6350803354439baa0a17e54e3d191565b2d9e140a380a4d59a71c676

#registry.tar 解压到/db10文件夹下

[root@d8a2bf957848 docker]# tar xvf registry.tar -C /db10

Docker容器绑定外部端口和IP

Docker允许通过外部访问容器或者容器之间互联的方式来提供网络服务

首先是外部访问容器

容器启动之后，容器中可以运行一些网络应用，通过-p或-P参数来指定端口映射，使用-P（大写）标记时，docker会随机选择一个端口映射到容器内部开放的网络端口上

-d 后台运行

0.0.0.0:32798 -> 5000/tcp

外部随机分配一个端口 32795

容器里面的外部服务 5000/tcp

查看信息

docker logs 名字
docker port  名字

绑定指定的ip和端口 到容器某一个端口 — ip:hostport:containerport

绑定某一个ip的所有端口到容器的端口 ---- ip::containerport

值绑定某一个端口到容器端口，不管ip —hostport:containerport

使用-p（小写)则可以指定要映射的端口，并且在一个指定端口上只可以绑定一个容器，支持的格式有

web5000的端口，和容器的5000端口进行映射 启动了外部应用 python app.py

docker run -d -p 5000:5000 training/webapp python app.py

docker 默认会映射本地所有的地址。现在我们来尝试一下映射到指定地址的指定端口 访问到容器里面的web应用(python app.py)

docker run -d -p 127.0.0.1:5000:5000 training/webapp python app.py

然后要访问容器中的应用只能通过127.0.0.1这个ip访问。

接下来是绑定本机的任意端口到容器的5000端口

docker run -d -p 127.0.0.1::5000 training/webapp python app.py

docker inspect

容器内部有自己的内部网络和ip地址，可以使用docker inspect来查看

在启动容器的时候，可以多次使用-p标记来绑定多个端口

docker run -d -p 5005:5000 -p 5006:80 training/webapp python app.py

Docker容器互联 容器与容器之间互联

除了端口映射之外，容器互联是另一种跟容器应用交互的方式。它会在源容器和接收容器之间建立一个隧道，接收容器可以看到源容器指定的信息

要实现容器互联，需要为容器指定一个好几的名字，通过–name来制定，若不指定，docker会随机生成一个容器的名称，但这不利于记忆

#名字为test1，晒出来的信息

docker inspect -f "{{.Name}}" test1

不指定-f "{{.Name}}"则会显示所有的信息

容器互联：使用–link参数，可以让容器之间安全的进行交互

a.先穿件一个数据库容器
docker run -d --name db training/postgres

b.新建一个容器和postgres容器互联
docker run -d -P --name web --link db:db training/webapp python app.py

我们可以查看下web容器的环境变量

docker run --rm --name web2 --link db:db training/webapp env

例子

第一步骤 本地有这个python镜像

[root@bogon first]# docker search python
[root@bogon first]# docker pull docker.io/centos/python-36-centos7

第二步骤 首先创建Dockerfile:里面定义了我们构建镜像的指令步骤

Dockerfile

# 一个基础的 python 运行环境
FROM python
# 设置工作目录  在容器里面定义的软件、进程、他工作的目录 
WORKDIR /app
# 将当前系统文件夹内容复制到容器的 app 目录
ADD . /app
# 安装必要的依赖包
RUN pip install -r softwares.txt
# 开放端口，供容器外访问
EXPOSE 80
# 定义环境变量
ENV NAME Hello_docker
# 运行命令 
CMD ["python","app.py"]

app.py

from flask import Flask
from redis import Redis, RedisError
import os
import socket
# Connect to Redis

redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)

app = Flask(__name__)
@app.route("/")

def hello():
        try:
                visits = redis.incr("counter")
        except RedisError:
                visits = "<i>cannot connect to Redis, counter disabled</i>"
        html = "<h3>Hello {name}!</h3>" \
                        "<b>Hostname:</b> {hostname}<br/>" \
                        "<b>Visits:</b> {visits}"
        return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname(), visits=visits)

if __name__ == "__main__":
        app.run(host='0.0.0.0', port=80)

softwares.txt

第三步骤 创建镜像

-t 给镜像赋值一个名字 first_image

从当前目录寻找Dockerfile文件,上传到docker服务器里面去，解释里面的指令，按照Dockerfile指令一行一行执行

[root@bogon first]# docker build -t first_image .

第四步骤 启动容器

web服务，提供web访问 -p 端口映射 8888映射容器80端口

[root@bogon first]# docker run -p 8888:80 first_image

[root@bogon ~]# curl http://192.168.10.80:8888

在hosts文件，hadoop2对应的机器ip

第五步骤 把redis装到独立容器里面

[root@bogon ~]# docker pull redis

[root@bogon ~]# docker images | grep redis

#redis镜像生成一个容器

docker run --name redis -d redis

#启动redis容器

[root@bogon ~]# docker start redis

#需要进入容器启动redis服务

[root@bogon ~]# docker ps

#!/bin/bash
nsenter --target $1 --mount --uts --ipc --net --pid /bin/bash

[root@bogon centos]# pwd
/root/docker/centos

chmod 775 nsenter.sh

#!/bin/bash
docker_in(){
        NAME_ID=$1
        PID=$(docker inspect --format "{{ .State.Pid }}" $NAME_ID)
        nsenter --target $PID --mount --uts --ipc --net --pid /bin/bash
}
docker_in $1

#进入容器

[root@bogon centos]# ./nsenter.sh b6e83132a3d2

将我们redis容器，–link 链接到我们即将运行的容器里面，使得我们这个容器链接redis里面

–link 为容器取的别名redis，会被写道/etc/host的里面去

first_image 镜像的名字

[root@bogon ~]# docker run -d --name first_hello3 --link redis:redis -p 9876:80 first_image

进入容器找到进程的编号

在可以使用docker inspect来查看该容器的详细信息。
docker inspect 44fc0f0582d9
docker inspect -f {{.State.Pid}} 44fc0f0582d9

#进入容器

[root@bogon centos]# ./nsenter.sh b6e83132a3d2

重启容器

[root@bogon first]# docker restart first_hello3

成功

Dockerfile基本结构讲解

Dockerfile 是一个文本格式的配置文件，用户可以使用Dockerfile快速创建自定义的镜像。

Sending build context to Docker deamon 4.608 kb

发送到docker服务器 ，会解析这个文件 ，从上至下依次执行,每执行都会生成一层镜像

Dockerfile文件分为四个部分，下面会分别讲到

1. 基础镜像信息 在Dockerfile中使用#完成一行的注解
   #第一行必须制定基础镜像 FROM centos
2. 维护者信息#维护者信息
   MAINTAINER your_name your_email
3. 镜像操作指令#镜像操作指令，使用yum 安装mysql RUN yum -qqy install mysql
   当然这些指令还有包括ADD、ENV、EXPOSE等，我们在指令会详细讲解到
4. 容器启动执行指令 CMD
   [“python”,“app.py”] 每运行一条 RUN 指令，镜像则添加新的一层，最后的 CMD 指令，制定容器启动时要启动的命令

Dockerfile中的指令

Dockerfile中包括FROM、MAINTAINER、RUN、CMD、EXPOSE、ENV、ADD、COPY、ENTRYPOINT、VOLUME、USER、WORKDIR、ONBUILD等13个指令

FROM

格式为FROM image或FROM image:tag,并且Dockerfile中第一条指令必须是FROM指令，且在同一个Dockerfile中创建多个镜像时，可以使用多个FROM指令

MAINTAINER

格式为MAINTAINER user_name user_email，指定维护者信息

RUN

格式为RUN command或 RUN [“EXECUTABLE”,“PARAM1”,“PARAM2”…],前者在shell终端中运行命令，/bin/sh -c command ,例如：/bin/sh -c “echo hello”；后者使用exec执行，指定其他运行终端使用RUN[“/bin/bash”,“-c”,“echo hello”]

CMD

支持三种格式：
CMD [“executable”,“param1”,“param2”],使用exec执行，这是推荐的方式。

CMD command param1 param2 在/bin/sh中执行。

CMD [“param1",“param2”] 提供给ENTERYPOINT的默认参数。

CMD用于指定容器启动时执行的命令，每个Dockerfile只能有一个CMD命令，多个CMD命令只执行最后一个。若容器启动时

指定了运行的命令，则会覆盖掉CMD中指定的命令

EXPOSE

格式为 EXPOSE port [port2,port3,…],例如EXPOSE 80这条指令告诉Docker服务器暴露80端口，供容器外部连接使用。在启动容器的使用使用-P，Docker会自动分配一个端口和转发指定的端口，使用-p可以具体指定使用哪个本地的端口来映射对外开放的端口

ENV

格式为：EVN key value 。用于指定环境变量，这些环境变量，后续可以被RUN指令使用，容器运行起来之后，也可以在容器中获取这些环境变量

例如
ENV word hello
RUN echo $word

ADD

格式：ADD src dest （源目录拷贝到目标目录）

该命令将复制指定本地目录中的文件到容器中的dest中，src可以是是一个绝对路径，也可以是一个URL或一个tar文件，tar文件会自动解压为目录 —ADD当前系统的文件夹的目录拷贝到镜像里面

COPY

格式为：COPY src desc
复制本地主机src目录或文件到容器的desc目录，desc不存在时会自动创建

COPY docker-entrypoint.sh  /usr/local/bin/   #复制docker-entrypoint.sh到本地的 /usr/local/bin/里面

ENTRYPOINT ["docker-entrypoint.sh"] #作为启动脚本

大部分情况,COPY优于ADD!
ADD除了COPY还有额外功能(解压)
添加远程文件/目录请使用curl或者wget

FROM centos
RUN yum install -y vim
RUN yum install -y wget
RUN yum install -y curl

ENTRYPOINT

格式有两种：
ENTRYPOINT [“executable”,“param1”,“param2”]
ENTRYPOINT command param1,param2 会在shell中执行。
用于配置容器启动后执行的命令，这些命令不能被docker run提供的参数覆盖。和CMD一样，每个Dockerfile中只能有一个ENTRYPOINT，当有多个时最后一个生效

ENTRYPOINT 执行命令

“/bin/echo” 这是命令

Exec的格式:执行的是echo 的命令 ，并不是一个shell

我们不是在shell执行echo，而是单纯执行echo ，如何把命令替换掉

VOLUME --数据卷

格式为 VOLUME [“/data"]
作用是创建在本地主机或其他容器可以挂载的数据卷，用来存放数据

USER

格式为：USER username (USER 指定某个用户来运行某个指令 )
指定容器运行时的用户名或UID，后续的RUN也会使用指定的用户。要临时使用管理员权限可以使用sudo。在
USER命令之前可以使用RUN命令创建需要的用户

例如：
进行打印

RUN groupadd -r docker && useradd -r -g docker docker

WORKDIR

格式： WORKDIR /path
为后续的RUN CMD ENTRYPOINT指定配置工作目录，可以使用多个WORKDIR指令，若后续指令用得是相对路径，则会基于之前的命令指定路径。

多个WORKDIR 进行叠加

WORKDIR  /APP
 WORKDIR  WEB
 RUN PWD

叠加的是 /APP/WEB

ONBUILD

格式ONBUILD [INSTRUCTION]
该配置指定当所创建的镜像作为其他新建镜像的基础镜像时所执行的指令。例如下面的Dockerfile创建了镜像A

ONBUILD ADD . /app
ONBUILD RUN python app.py

则基于镜像A创建新的镜像时，新的Dockerfile中使用from A 指定基镜像时，会自动执行ONBBUILD指令内容，等价于在新的要构建镜像的Dockerfile中增加了两条指令

FROM A
ADD ./app
RUN python app.py

/bin/bash把默认的CMD的给覆盖了

把退出docker 都删除掉 docker rm $(docker ps -qa)

只是进入到容器里面 没有打印 hello docker /bin/bash把默认的CMD的给覆盖了

docker run -it xiaopeng163/centos-cmd-shell /bin/bash

创建好Dockerfile之后

创建好Dockerfile之后，通过docker build命令来创建镜像，该命令首先会上传Dockerfile文件给Docker服务器端，服务器端将逐行执行Dockerfile中定义的指令。通常建议放置Dockerfile的目录为空目录。

git视频

通过-t 指定镜像的标签信息。

例如：docker build -t regenzm/first_image .

“.”指定的是Dockerfile所在的路径 --当前目录

docker安装python

docker安装pythondocker centos 镜像中安装python36详解在docker中安装python3.7Docker安装centos8并使用SSH远程连接ubuntu在docker中安装Python

Docker系列

Docker系列Docker 从入门到实践系列一 - 什么是DockerDocker 创建镜像、修改、上传镜像Dockerinfo

sql语句优化