标签: Docker

解决微服务在docker上部署后无法连接数据库的问题

在利用docker部署完应用程序后,就接着考虑如何将程序连接到数据库。

但是过程中发现一些问题:
本地程序在打包后连接的是本地的数据库,在服务器上部署之后必须提供相同的环境才能部署成功。

这里博主用的是宝塔安装的mysql,并尝试把用户名,数据库名,密码全部和自己的开发时的环境完全一致。
但是尝试多次之后,即便是修改的一模一样,在centos上运行还是报错。
这是当时连接数据库的url

url: jdbc:mysql://localhost:3306/数据库系统?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
1
想了多次还是无法理解,甚至尝试过在docker上再创建一个mysql的容器,但是提示3306的端口被占用了。
就在无可奈何准备放弃的时候,

当时看了下mysql的一些视频(因为快考数据库了),讲到navicat也是可以连接远程数据库的,当时想了下,觉的比较有趣,尝试了下,成功了,顿时觉得数据库的连接有出路了。

解决办法
将localhost换成自己服务器的ip地址
##前提是开放自己数据库的权限
也就是在开发时,连接的是自己服务器的数据库,这样即使你在任意的主机上也不存在数据库环境的问题了。

话说回来,为什么localhost不行呢?

除了 Docker,我们还有哪些选择?

所谓三十年河东,三十年河西,曾经在容器领域叱咤风云的 Docker 如今已风光不再。抛开情怀,我们不得不承认,Docker 已经被后浪拍死在沙滩上了……

大约 4 年前的容器领域,Docker 是唯一的选择。

然而,如今情况已然大不同,Docker 不再是是唯一的选择,它只不过是一个容器引擎而已。我们可以用 Docker 构建、运行、拉取、推送或检查容器镜像,但是这里的每一项任务,都可以用其他工具替代,甚至有些工具比 Docker 还好。

所以,下面就让我们来探索一下这个领域,然后卸载和忘记 Docker 吧。

%title插图%num

为什么说不要用 Docker 了?

如果长期以来你一直在使用 Docker,那么说服你考虑其他工具可能需要多费点唇舌。

首先,Docker 是一个整体化的工具,它试图做好所有的事情,但往往只会适得其反。在大多数情况下,我们应该选择专门的工具,它可能只做一件事情,但会做到*好。

可能你因为担心需要学习使用不同的 CLI、不同的 API 或接受不同的概念,所以会害怕使用其他工具。但是,请不用担心。本文介绍的任何工具都可以完美地无缝衔接,因为它们(包括 Docker)都遵循同一个 OCI(OpenContainer Initiative,开放容器计划)规范。OCI 包括容器运行时、容器分发和容器镜像的规范,涵盖了使用容器所需的所有功能。

因为有了 OCI,所以你可以自由选择适合自己的需求的工具,与此同时,你可以继续使用与 Docker 相同的 API 和 CLI 命令。

因此,如果你愿意尝试新工具,那么我们就来比较一下 Docker 与其竞争对手的优缺点和功能,看看是否有必要考虑放弃 Docker,并尝试使用一些新鲜出炉的工具。

%title插图%num

容器引擎

 

在比较 Docker 与其他工具时,我们需要分别讨论它的各个组件,首先要讨论的就是容器引擎。

容器引擎是一种工具,它提供了处理镜像与容器的用户界面,这样你就不需要与 SECCOMP 规则或 SELinux 策略苦苦纠缠了。除此之外,容器引擎还可以从远程仓库提取镜像,并将其解压到本地磁盘上。它似乎也运行容器,但是实际上,它的工作是创建容器清单以及镜像层的目录。接着,它将这些文件传递给 runc 或 crun 等容器运行时。

目前有很多容器引擎可供我们使用,不过 Docker *主要的竞争对手是红帽开发的 Podman。与 Docker 不同,Podman 不需要运行守护进程,也不需要 root 特权,这些都是 Docker 长期以来一直备受关注的问题。从名字就可以看出来,Podman 不仅可以运行容器,还可以运行 pod。

如果你不熟悉 pod 的话,我可以简单介绍一下:pod 是 Kubernetes 的*小计算单元,由一个或多个容器 (主容器与负责支持主容器的 sidercar 容器) 组成。因此,Podman 用户以后可以很轻松地将他们的工作负载迁移到 Kubernetes。

下面,我们通过一个简单的演示来说明如何在一个 Pod 中运行两个容器:

~ $ podman pod create --name mypod~ $ podman pod listPOD ID        NAME    STATUS    CREATED         # OF CONTAINERS   INFRA ID211eaecd307b  mypod   Running   2 minutes ago   1                 a901868616a5 ~ $ podman run -d --pod mypod nginx  # First container~ $ podman run -d --pod mypod nginx  # Second container~ $ podman ps -a --pod CONTAINER ID IMAGE                          COMMAND               CREATED        STATUS            PORTS  NAMES               POD           POD NAME3b27d9eaa35c  docker.io/library/nginx:latest  nginx -g daemon o...  2 seconds ago Up 1 second ago         brave_ritchie      211eaecd307b  mypodd638ac011412 docker.io/library/nginx:latest nginx -g daemon o...  5 minutesago  Up 5 minutes ago         cool_albattani      211eaecd307b mypoda901868616a5 k8s.gcr.io/pause:3.2                                  6 minutesago  Up 5 minutes ago         211eaecd307b-infra  211eaecd307b mypod

*后一点,Podman 提供的 CLI 命令与 Docker 完全相同,因此你只需执行

alias docker=podman

然后就像什么都没有发生过一样。

除了 Docker 和 Podman 之外,还有其他容器引擎,但我并不看好它们的发展,或者不适合用于本地开发。

不过,如果你想对容器引擎有一个较为完整的了解,我也可以介绍一些:

  • LXD:LXD 是 LXC(Linux 容器)的容器管理器(守护进序)。这个工具提供了运行系统容器的能力,而这些系统容器提供了类似于虚拟机的容器环境。该工具比较小众,没有太多用户,所以除非你有非常特殊的用例,否则*好还是使用 Docker 或 Podman。
  • CRI-O:如果在网上搜索 cri-o 是什么,你可能会发现它被描述成了一种容器引擎。但实际上,它是一种容器运行时。它既不是容器引擎,也不适合“常规”使用。我的意思是说,它是专门作为 Kubernetes 运行时(CRI)而创建的,并不是给*终用户使用的。
  • rkt:rkt(读作“rocket”)是 CoreOS 开发的容器引擎。这里提到这个项目只是为了清单的完整性,因为这个项目已经结束了,它的开发也停止了,因此你不应该再使用它。

%title插图%num

构建镜像

 

对于容器引擎,实际上 Docker 的替代品只有一种选择(即 Podman)。但是,在构建镜像方面,我们有很多选择。

首先,我们来看一看 Buildah。这也是一款红帽开发的工具,可以很好地与 Podman 协同工作。如果你已经安装了 Podman,可能会注意到 podman build 子命令,因为它的二进制文件已经包含在 Podman 中了,实际上这个命令只是经过包装的 Buildah。

至于功能,Buildah 沿用了 Podman 的方针:没有守护进程,不需要 root 特权,而且生成的是符合 OCI 的镜像,因此你的镜像的运行方式与使用 Docker 构建的镜像完全相同。它还能使用 Dockerfile 或 Containerfile 构建镜像, Dockerfile 与 Containerfile 实际上是同一个东西,只是叫法不同罢了。除此之外,Buildah 还提供了对镜像层更精细的控制,支持提交大量的变更到单个层。我认为,它与 Docker 之间有一个出乎意料的区别(但这个区别是好事),那就是使用 Buildah 构建的镜像特定于用户,因此你可以只列出自己构建的镜像。

你可能会问,既然 Podman CLI 中已经包含了 Buildah,为什么还要使用单独的 Buildah CLI 呢?其实,Buildah CLI 是 podman build 所包含的命令的超集,因此你可能不需要直接使用 BuildahCLI,但是通过使用它,你可能会发现一些额外的功能。

下面,我们来看一个示例:

~ $ buildah bud -f Dockerfile . ~ $ buildah from alpine:latest  # Create starting container - equivalent to"FROM alpine:latest"Getting image source signaturesCopying blob df20fa9351a1 doneCopying config a24bb40132 doneWriting manifest to image destinationStoring signaturesalpine-working-container # Name of the temporary container~ $ buildah run alpine-working-container -- apk add--update --no-cache python3  # equivalentto "RUN apk add --update --no-cache python3"fetchhttp://dl-cdn.alpinelinux.org/alpine/v3.12/main/x86_64/APKINDEX.tar.gzfetchhttp://dl-cdn.alpinelinux.org/alpine/v3.12/community/x86_64/APKINDEX.tar.gz... ~ $ buildah commit alpine-working-containermy-final-image  # Create final imageGetting image source signaturesCopying blob 50644c29ef5a skipped: already existsCopying blob 362b9ae56246 doneCopying config 1ff90ec2e2 doneWriting manifest to image destinationStoring signatures1ff90ec2e26e7c0a6b45b2c62901956d0eda138fa6093d8cbb29a88f6b95124c ~ # buildah imagesREPOSITORY              TAG     IMAGE ID      CREATED         SIZElocalhost/my-final-image latest  1ff90ec2e26e 22 seconds ago  51.4 MB

从上面的脚本可以看出,你可以直接使用 buildah bud 构建镜像,其中 bud 代表使用 Dockerfile 进行构建,你也可以使用其他脚本化的方法,比如使用 Buildahs 的 from、run 和 copy,它们分别对应 Dockerfile 中的 FROM、RUN、COPY 命令。

接下来是 Google 的 Kaniko。Kaniko 也是利用 Dockerfile 构建容器镜像,而且与 Buildah 类似,它也不需要守护进程。但它与 Buildah 的主要区别在于,Kaniko 更加侧重于 Kubernetes 中的镜像构建。

Kaniko 本身也要作为镜像(gcr.io/kaniko-project/executor) 运行,这对于Kubernetes 来说是没有问题的,但对于本地构建来说不是很方便,并且在某种程度上违背了构建镜像的目的,因为你需要使用 Docker 运行 Kaniko 镜像才能构建镜像。话虽如此,如果你正在寻找在 Kubernetes 集群中构建镜像的工具 (例如在 CI/CD 管道中),那么 Kaniko 可能是一个不错的选择,因为它不需要守护进程,而且更安全。

以我个人的经验来看,我认为两者都能很好地完成工作,但是使用 Kaniko 时,我遇到了一些随机的构建故障,而且在将镜像推送到仓库时也出现了失败的情况。

我要介绍的第三个工具是 buildkit,也可以称之为 docker build 二代。它是 Moby 项目的一部分(与 Docker一样),只需设置 DOCKER_BUILDKIT=1 docker build,就可以启动这个工具,并作为 Docker 的一个实验性功能使用。那么,这个工具究竟能给你带来什么?它带来了很多改进和很酷的功能,包括并行构建、跳过未使用的阶段、更好的增量构建以及不需要 root 权限等构建。但是,它仍然需要运行守护进程 (buildkitd)。因此,如果你不想摆脱 Docker,同时又想要一些新的功能和改进,那么可以考虑一下 buildkit。

这里,我也会列出一些其他的工具,它们有各自的特定用途,但不是我的首选:

  • Source-To-Image(S2I):这是一个不使用 Dockerfile,直接根据源代码构建镜像的工具包。这个工具在简单的预期场景和工作流中表现良好,但如果你需要多一些自定义,如果你的项目的结构不符合预期,那么它就变得非常烦人和笨拙。如果你对 Docker 不太满意,或者你在 OpenShift 集群上构建镜像,则可以考虑使用 S2I,因为使用 S2I 构建镜像是它的一个内置功能。
  • Jib:这是一款由 Google 开发的工具,专门用于构建 Java 镜像。它提供了 Maven 和 Gradle 插件,可以让你轻松地构建镜像,而无需在意 Dockerfile。
  • Bazel:这也是一款由 Google 开发的工具。它不仅可用于构建容器镜像,而且是一个完整的构建系统。如果你只是想构建镜像,那么使用 Bazel 可能会有点大材小用,但*对是一种不错的学习体验,如果你愿意,可以先从 rules_docker 着手。

%title插图%num

容器运行时

 

*后我们来说说负责运行容器的容器运行时。容器运行时是整个容器生命周期的一部分,除非你对速度、安全性等有一些非常特殊的要求,否则请不要乱动它。

看到这里,如果你感到厌倦了,则可以跳过这一部分。但是,如果你想了解一下在容器运行时方面,都有哪些选择,则可以看看下面这些:

runc 是一款流行的容器运行时,且符合 OCI 容器运行时规范。Docker(通过containerd)、Podman 和 CRI-O 都在使用它,因此无需我多言。它几乎是所有容器引擎的默认设置,因此即便你在阅读本文后抛弃了 Docker,很可能仍然会使用 runc。

runc 的另一种替代品是 crun。这是一款由红帽开发的工具,全部用 C 语言编写(runc 是用 Go 编写的),所以它比 runc 更快,内存效率更高。由于它也是兼容 OCI 的运行时,所以如果你想试试看的话,应该能很快上手。虽然它现在还不是很流行,但是它即将作为 RHEL 8.3 版本的备选 OCI 运行时,出现在技术预览中,而且考虑到它是红帽的产品,所以*终很可能会成为 Podman 或 CRI-O 的默认配置。

说到 CRI-O,前面我说过,它并不是容器引擎,而是容器运行时。这是因为 CRI-O 没有推送镜像之类的功能,但这些功能是容器引擎应该具备的。CRI-O 内部使用 runc 来运行容器。你不应该在自己的机器上尝试使用这个运行时,因为它的设计就是 Kubernetes 节点上的运行时,而且它是“Kubernetes 所需的唯一的运行时”。因此,除非你要建立 Kubernetes 集群,否则就不应该考虑 CRI-O。

*后一个是 containerd,它是云原生计算基金会即将推出的一个项目。它是一个守护进程,可作为各种容器运行时和操作系统的 API 接口。它后台依赖于 runc,它是 Docker 引擎的默认运行时。Google Kubernetes Engine(GKE)和 IBM Kubernetes Service(IKS)也在使用它。它是 Kubernetes容器运行时接口的一个实现(与 CRI-O 一样),因此是 Kubernetes 集群运行时的理想选择。

%title插图%num

镜像的检查与分发

 

*后一部分内容是镜像的检查与分发,主要是为了替代 docker inspect,并增加在远程仓库之间复制镜像的能力(可选)。

在这里,我要提到的唯一可以完成这些任务的工具是 Skopeo。它由红帽开发,是 Buildah、Podman 和 CRI-O 的附属工具。除了基本的 skopeo inspect(Docker 有相应的命令),Skopeo 还可以通过 skopeo copy 令来复制镜像,因此你可以直接在远程仓库之间复制镜像,无需将它们拉取到本地。如果你使用本地仓库,那么这个功能也可以作为拉取/推送。

另外,我还想提一下 Dive,这是一款检查、探索和分析镜像的工具。它更加人性化,提供了更加方便阅读的输出,而且还可以更深入地挖掘镜像,并分析和测量镜像的效率。此外,它也很适合在 CI 管道中使用,用于衡量你的镜像是否“足够高效”,或者换句话说,是否浪费了太多空间。

一目了然的 Docker 环境配置指南

Docker是一个开源的引擎,可以轻松的为任何应用创建一个轻量级的、可移植的、自给自足的容器。开发者在笔记本上编译测试通过的容器可以批量地在生产环境中部署,包括VMs(虚拟机)、 bare metal、OpenStack 集群和其他的基础应用平台。

Docker通常用于如下场景:

  • web应用的自动化打包和发布;
  • 自动化测试和持续集成、发布;
  • 在服务型环境中部署和调整数据库或其他的后台应用;
  • 从头编译或者扩展现有的OpenShift或Cloud Foundry平台来搭建自己的PaaS环境。

正因为Docker强大的功能,越来越多的场景下,需要我们使用Docker部署和发布我们的代码。今天就梳理下,如何入门Docker。

%title插图%num

%title插图%num

本地环境安装docker工具

  ubutun安装

这里以阿里云ECS(ubutun)下安装docker为例。命令行安装:

sudo apt install docker.io

验证:

docker info

  Mac安装,下载MAC版本的docker:

https://hub.docker.com/editions/community/docker-ce-desktop-mac/

  Windows安装,下载Windows版本的docker:

https://hub.docker.com/editions/community/docker-ce-desktop-windows/

注意:下载成功后,直接install就可以了,一路Next即可安装完成。申请自己的docker id,登陆;

%title插图%num

创建镜像仓库

这里以申请阿里云容器镜像服务(免费),并创建仓库为例,其他仓库如dockerhub、谷歌、亚马逊、腾讯等详见对应产品说明书。

阿里云容器服务地址为:https://cr.console.aliyun.com

注册开通后产品页面如下

%title插图%num

  1. 创建命名空间

*步切换标签页到命名空间,创建地址唯一的命名空间

%title插图%num

根据大赛要求选择对应的地域,其他的按照自己需求选择或填写

%title插图%num

2. 创建镜像仓库

下一步,选择本地仓库,不建议其他选项,完成创建

%title插图%num

点击管理,可查看详情。

%title插图%num%title插图%num

3.完成本地登录

按照页面的指令在本地完成登陆:

%title插图%num

  1. export DOCKER_REGISTRY= your_registry_url<docker registry url> (注意这里your_registry_url*后字段结尾,不能多不能少
  2. E.g registry.cn-shanghai.aliyuncs.com/xxxx/xxxx) docker login $DOCKER_REGISTRY \ –username your_username \ –password your_password

%title插图%num

构建镜像并推送

在安装好Docker环境的本机/服务器构建并推送容器镜像。过程中可能会使用docker命令,如拉取docker pull,推送docker push,构建docker build等等。

为简化构建镜像的难度,天池已准备了常用的Python基础镜像,可直接拉取使用,自行构建镜像请确保安装curl.更多基础镜像说明可参考:https://tianchi.aliyun.com/forum/postDetail?postId=67720。

docker pull registry.cn-shanghai.aliyuncs.com/tcc-public/python:3

  1. 准备所需文件

新建一个文件夹(例如tianchi_submit_demo)用于存放这次任务镜像所需的文件,文件夹中内容示例,其中hello_world.py中是各位自己的代码部分:

%title插图%num

Dockerfile配置文件参考,Dockerfile是固定名称,注意首字母大写。Dockerfile中命令皆大写:

  1. # Base Images
  2. ## 从天池基础镜像构建
  3. FROM registry.cn-shanghai.aliyuncs.com/tcc-public/python:3
  4. ## 把当前文件夹里的文件构建到镜像的根目录下
  5. ADD . /
  6. ## 指定默认工作目录为根目录(需要把run.sh和生成的结果文件都放在该文件夹下,提交后才能运行)
  7. WORKDIR /
  8. ## 镜像启动后统一执行 sh run.sh
  9. CMD [“sh”“run.sh”]

run.sh参考:

python hello_world.py

  2. 构建镜像并推送(2.1及2.2皆可)

2.1 IDE + Cloud Toolkit

推荐使用 Alibaba Cloud Toolkit:

https://cn.aliyun.com/product/cloudtoolkit 进行操作。

Cloud Toolkit 与主流 IDE 及阿里云容器镜像服务无缝集成,可以简化操作。这里以在 IntelliJ IDEA 中使用 Alibaba Cloud Toolkit 为例。只需配置一次,之后都可一键推送~

2.1.1. 安装及配置

在本地 IDE 中安装 Alibaba Cloud Toolkit 并进行阿里云账户配置。

参见:在 IntelliJ IDEA 中安装和配置 Cloud Toolkit:https://help.aliyun.com/document_detail/98762.html

2.1.2. 设置环境

设置用于打包本地镜像的 Docker 环境。

  1. 在 IntelliJ IDEA 工具栏单击 Tools > Alibaba Cloud > Preferences…
  2. 在 Settings 对话框的左侧导航栏中单击 Docker
  3. 在 Docker 界面中设置 Cloud Toolkit 需要连接的 Docker 环境。

注意:如果出现连接测试报错,可进入 Docker 的 Settings 界面,单击左侧导航栏中的 General,然后选择 Expose daemon on tcp://localhost:2375 without TLS。

%title插图%num

  • 本地为 Mac 或 Linux 操作系统,勾选 Unix Socket,然后单击 Browse,输入unix:///var/run/docker.sock
  • 本地为 Windows 操作系统,勾选 TCP Connection,然后在 URI 右侧文档框输入本地 Docker 的 URI,如 http://127.0.0.1:2375。
  • 远程 Docker 环境:勾选 Tcp Connection,在 URI 右侧的文本框里输入远端的 Docker 环境的 URI(包括 IP 地址和端口),如 http://x.x.x.x:2375,并确保远程主机的 HTTP 服务开启。
  • 单击 Test Connection 进行连接测试。

2.1.3. 构建并上传应用

  1. 在 IntelliJ IDEA 的菜单栏中选择 File > Open… ,选择参赛的工程文件。
  2. 在 IntelliJ IDEA 界面左侧的 Project 中右键单击您的 Docker 应用工程名,在弹出的下拉菜单中选择 Alibaba Cloud > Deploy to ACR/ACK > Deploy to ACR
  3. 在 Deploy to ACR 对话框中进行以下配置。
  • Context Directory:参赛的工程文件所在的目录,例如上文中的 tianchi_submit_demo 。
  • Dockerfile:选择上文中创建的 Dockerfile。
  • Version:对上传的工程文件做版本标记。例如 1.0
  1. 在 Image 页签中选择Context Directory和Dockerfile。
  2. 在 Image Repositories 区域选择上文中创建的容器镜像服务的地域、命名空间和镜像仓库。

2.1.4. 单击 RUN

%title插图%num

下次就可以一键完成了~

2.2 服务器上直接操作

执行

docker build -t registry.cn-shenzhen.aliyuncs.com/test_for_tianchi/test_for_tianchi_submit:1.0 .

注意:registry.~~~是上面创建仓库的公网地址,用自己仓库地址替换。地址后面的:1.0为自己指定的版本号,用于区分每次build的镜像。*后的.是构建镜像的路径,不可以省掉。

%title插图%num

构建完成后可先验证是否正常运行,正常运行后再进行推送。

CPU镜像:

docker run your_image sh run.sh

GPU镜像:

nvidia-docker run your_image sh run.sh

推送到镜像仓库

docker push registry.cn-shenzhen.aliyuncs.com/test_for_tianchi/test_for_tianchi_submit:1.0

如果这步出错,可能你没有登录,按照仓库里描述操作登录即可。

%title插图%num

*次推送会比较耗时,可以休息一会了~o( ̄▽ ̄)d

%title插图%num

提交验证运行结果

在左侧【提交结果】中填写推送的镜像路径、用户名和密码,即可提交。根据【我的成绩】中的分数和日志可以查看运行情况。

%title插图%num

%title插图%num

常见问题及解决方案

问题1. 如果你是在本机使用脚本build 镜像如docker build -t resgist… .可能会报错如下:

ERROR: Could not open requirements file: [Errno 2] No such file or directory'C:/Users/wyx/Desktop/tianchi_docker/requirements.txt'

解决方法:在Dockerfile文件的安装依赖包之前加一行COPY requirements.txt requirements.txt

问题2.  登陆镜像仓库失败,提示账号密码错误,请注意这里的账号密码非阿里云的账号密码而是你开通仓库服务时设置的账号密码,如果忘记密码,找回路径如下:

找回容器镜像登录密码

%title插图%num

问题3. push 完成后刷新仓库网页看不到镜像版本,担心上传失败

容器镜像网页存在一定的延迟,只要你本地push命令行没有出错就大胆去大赛提交即可,如果实在不放心你可以删除本地镜像然后pull一下验证。

利用Docker构建开发环境

*近接触PAAS相关的知识,在研发过程中开始使用Docker搭建了自己完整的开发环境,感觉生活在PAAS时代的程序员真是幸福,本文会简要介绍下Docker是什么,如何利用Docker来搭建自己的开发环境(本文主要是面向Mac OS X),以及期间所遇到的一些坑和解决方案。(本文会要求你对PAAS、LXC、CGroup、AUFS有一定的了解基础,请自行Google )

大背景–虚拟化技术历史

计算机虚拟化技术由来已久,从硬件仿真到全虚拟化,再到准虚拟化和操作系统虚拟化,各种技术粉墨登场,种类繁多,说实在的有点眼花缭乱和复杂;但用户的核心诉求一直是比较简单的,降低信息技术(IT)的运营成本,提高资源利用率,提高安全性和可靠性等等;虽说用户的核心诉求比较简单,但每个时代的需求场景却是不同的。在大型机时代,虚拟化技术被用来支持多个用户能够同时使用大型机,在x86架构时代,随着企业服务的大规模部署,虚拟化技术主要是用来提高企业资源的利用率,而现如今,随着云计算时代的到来,人们对应用的安全性、隔离性越来越高,对于部署的标准化以及虚拟机的性能要求越来越高。现如今,一种叫Linux容器的虚拟化技术逐渐得到广泛的应用,它的优点有许多,本文不一一赘述,有太多的文章可以参考。

什么是Docker?

docker的英文本意是码头工人,也就是搬运工,这种搬运工搬运的是集装箱(Container),集装箱里面装的可不是商品货物,而是任意类型的App,Docker把App(叫Payload)装在Container内,通过Linux Container技术的包装将App变成一种标准化的、可移植的、自管理的组件,这种组件可以在你的latop上开发、调试、运行,*终非常方便和一致地运行在production环境下。

Docker的核心底层技术是LXC(Linux Container),Docker在其上面加了薄薄的一层,添加了许多有用的功能。这篇stackoverflow上的问题和答案很好地诠释了Docker和LXC的区别,能够让你更好的了解什么是Docker, 简单翻译下就是以下几点:

  • Docker提供了一种可移植的配置标准化机制,允许你一致性地在不同的机器上运行同一个Container;而LXC本身可能因为不同机器的不同配置而无法方便地移植运行;
  • Docker以App为中心,为应用的部署做了很多优化,而LXC的帮助脚本主要是聚焦于如何机器启动地更快和耗更少的内存;
  • Docker为App提供了一种自动化构建机制(Dockerfile),包括打包,基础设施依赖管理和安装等等;
  • Docker提供了一种类似git的Container版本化的机制,允许你对你创建过的容器进行版本管理,依靠这种机制,你还可以下载别人创建的Container,甚至像git那样进行合并;
  • Docker Container是可重用的,依赖于版本化机制,你很容易重用别人的Container(叫Image),作为基础版本进行扩展;
  • Docker Container是可共享的,有点类似github一样,Docker有自己的INDEX,你可以创建自己的Docker用户并上传和下载Docker Image;
  • Docker提供了很多的工具链,形成了一个生态系统;这些工具的目标是自动化、个性化和集成化,包括对PAAS平台的支持等;

那么Docker有什么用呢?对于运维来说,Docker提供了一种可移植的标准化部署过程,使得规模化、自动化、异构化的部署成为可能甚至是轻松简单的事情;而对于开发者来说,Docker提供了一种开发环境的管理方法,包括映像、构建、共享等功能,而后者是本文的主题。

Docker的安装和构成

Docker官方本身提供了非常具体的安装教程,这里不说具体的安装过程,请参考Docker安装(Mac系统),重要的是描述下原理和安装完成后的结构,好对Docker更好的了解。 由于LXC本身不支持Mac内核,因此需要跑一个VirtualBox虚拟机(TinyCoreLinux)来安装,幸好Docker社区提供了一个非常方便的工具boot2docker(其实就是一个VBoxManage的包装shell脚本),用于安装Mac下的整个Docker环境。具体的结构如下:

docker-install

如图所示,安装完成后,具体情况如下:

  • 在Mac的home目录~/.boot2docker下创建了虚拟机所需要的文件,其中boot2docker.iso是虚拟机映像,这是一个由CD-ROM引导的TinyCoreLinux系统;而boot2docker-vm.vmdk文件则是你的虚拟机磁盘,你所有的持久化数据都存放在这里,包括docker创建的lxc容器等文件。
  • 在Mac下,docker被分为客户端docker-client和服务端docker-daemon两部分,如果是在linux(比如ubuntu),实际上则是同一个可执行文件同时充当客户端和服务端。docker-daemon可以监听unix scoket,也可以在tcp socket(默认端口为4234),docker-client会通过一个叫DOCKER_HOST的环境变量读取服务地址和端口,因此你应该在你的bash_profile文件里面添加这么一行:

docker-daemon跑在虚拟机上,这个程序实际上就是接收docker-client发送过来的消息命令,创建、启动和销毁lxc容器,以及docker本身的版本管理、映像存储等等 运行你的*个docker容器 安装完成后,就差不多可以开始创建和运行docker容器了,在这之前,你首先得下载一个Image,什么是Image?我们先来了解docker的2个基础概念:Image和Container。

Container和Image 在Docker的世界里,Image是指一个只读的层(Layer),这里的层是AUFS里的概念,*直观的方式就是看一下docker官方给出的图:

docker-filesystems-multilayer

Docker使用了一种叫AUFS的文件系统,这种文件系统可以让你一层一层地叠加修改你的文件,*底下的文件系统是只读的,如果需要修改文件,AUFS会增加一个可写的层(Layer),这样有很多好处,例如不同的Container可以共享底层的只读文件系统(同一个Kernel),使得你可以跑N多个Container而不至于你的硬盘被挤爆了!这个只读的层就是Image!而如你所看到的,一个可写的层就是Container。

那Image和Container的区别是什么?很简单,他们的区别仅仅是一个是只读的层,一个是可写的层,你可以使用docker commit 命令,将你的Container变成一个Image,也就是提交你所运行的Container的修改内容,变成一个新的只读的Image,这非常类似于git commit命令,感觉真棒!

实际上这就是Docker对Container映像的版本管理基石,AUFS文件系统实在是太美妙了,更多细节可以参考DotCloud的这篇文章

运行和退出

在了解了Image和Container的概念后,我们可以开始下载一个Image,Docker的好处就是提供了一个类似github的Image仓库管理,你可以非常方便pull别人的Image下来运行,例如,我们可以下载一个ubuntu Image:

这里的13.10是一个Tag,类似于git的tag,这里的tag可以为你制定一个ubuntu的版本。下载完成后,执行docker images命令可以列出你已经下载或者自己构建的image:(请允许我使用可爱的马赛克 🙂 )

QQ20140322-1

你可以看到ubuntu:13.10的大小为178MB,以及它的IMAGE ID。 现在我们开始运行一个Container,命令很简单,例如我们想运行一个执行Shell终端的Container:

QQ20140322-2

如你看到的,你已经进入到一个Shell里面,可以执行你想执行的任何命令,就和在ubuntu里面一样,进去后默认是在根目录/下,可以看到经典的unix/linux目录结构,以及你所运行的bash版本等信息。你可以给你的Container定一个名字,通过–name选项,例如这里命名了shell,日后你就可以直接用这个名字引用Contanier。

退出一个Container也很简单,你直接exit就好了。 其他更多的命令这里不做赘述,因为官方的文档已经非常全面,这里只是给一个直观的初步印象。下面进入主题。

利用Docker搭建开发环境

我们先看看程序员在搭建开发环境时遇到的一些问题:

  • 软件安装麻烦,比如很多公司都使用redhat,一般开发人员又不给root,安装一个nginx或者是mysql都得自己下载编译安装 权限问题,没有root,一些软件无法运行,例如dnsmasq;
  • 没有root,无法修改hosts,无法netstat -nptl,无法tcpdump,无法iptable
  • 隔离性差,例如不同的开发人员如果在同一台主机环境下共享开发,虽然是用户隔离,但端口如果不规范可能会冲突;同一个Mysql如果权限管理不好很有可能误删别人的数据
  • 可移植性差,例如和生产环境不一致,开发人员之间也无法共享;更严重的情况是当有新人入职时,通常需要又折腾一遍开发环境,无法快速搭建

这些问题可以通过在本地搭建虚拟机来解决,但虚拟机是一个很笨重的解决方案,Docker是一个非常轻量级的方案,而且还拥有虚拟机没有的一些功能,例如标准化Image,Image共享等,更重要的是,利用Docker,你可以运行非常多的容器,在你的Mac下搭建一个分布式的开发环境根本不是什么大的问题,而且对内存、磁盘和cpu的消耗相比传统的虚拟机要低许多,这些都要归功于AUFS和LXC这两大神奇的技术。

构建基础Image

想要搭建一个节省磁盘空间和扩展性良好的开发环境,*重要的*步就是构建一个基础性的Image,比如你的主要开发语言是Ruby,那么你肯定需要一个已经安装好以下工具的基础Image:

  • ruby
  • bundler
  • gem

然后在此基础上,你可以扩展这个基础的Image(下面叫base)为不同的开发环境,例如rails,或者是nats。当然,你的这个base也可以从别人的Image扩展而来,还记得我们刚刚pull下来的ubuntu:13.10这个Image吗?你可以从这个Image扩展开始构建你的base,如何做呢?Docker提供了一种标准化的DSL方式,你只需要编写一个Dockerfile,运行docker build指令,就可以构建你自己的Image,这有点像Makefile和make命令一样,只是大家要构建的内容和构建语言不同。

Dockerfile的语法请参考Dockerfile Reference,这里给出上面提到的Ruby开发的base Dockerfile示例:

这里只用到了很简单的2个指令:FROM和RUN,FROM指定了我们要扩展的Image,RUN指定我们要运行的命令,这里是安装ruby,gem、bundler等软件。写好Dockerfile后,运行以下指令就可以创建你的base image了:

-t 选项是你要构建的base image的tag,就好比ubuntu:13.10一样 –rm 选项是告诉Docker在构建完成后删除临时的Container,Dockerfile的每一行指令都会创建一个临时的Container,一般你是不需要这些临时生成的Container的 如你所想,我们可以像运行ubuntu:13.10那样运行我们的base了:

这里我们使用dev:base这个Image运行了一个irb解释器(Ruby的交互式解释器)。 在构建完base之后,你可以依样画葫芦构建你的rails环境,很简单,只需要FROM dev:base,然后RUN安装你的rails组件就可以了,不再赘述。*终你可能构建的开发环境是这样的:

docker-dev

如上图所示,base和service都是从ubutnu:13.10继承而来,他们作为不同的基础开发环境,base是ruby开发环境(也许命名为dev:ruby更为合适?),而service是一些基础数据服务,例如mysql,memcache,我建议将这些第三方组件集中在一个Container中,因为他们的环境不经常修改,可以作为一种底层服务Container运行,除非你需要构建分布式的服务,例如memcache集群,那可以继续拆分。

指定Image入口

当你构建完你的base Image和其他应用的Image之后,你就可以启动这些Image了,还记得前面我们给出的运行命令吗?

这里我们运行了一个bash,这样你就可以在shell里面执行你所想要执行的任何命令了,但是我们有时候并不想每次都启动一个shell,接着再在shell里面启动我们的程序,比如一个mysql,而是想一启动一个容器,mysql服务就自动运行了,这很简单,Dockerfile提供了CMD和ENTRYPOINT这2个指令,允许你指定一个Image启动时的默认命令。CMD和ENTRYPOINT的区别是CMD的参数可以由docker run指令指定的参数覆盖,而ENTRYPOINT则不可以。例如我们想运行一个memcached服务,可以这么写Dockerfile:

或者可以这么写:

注意不要把memcached启动为后台进程,即加上-d选项,否则docker启动的container会马上stop掉,这点我也觉得比较意外。 接着我们build这个Image:

这样,当你build完你的Image后,你可以直接将该Image运行为一个容器,它会自动启动mysql服务:

注意使用-d (detach) 选项,这样这个container就会作为后台进程运行了,接着你可以使用docker ps命令查看是否有在运行。

磁盘映射

大部分时候你会需要把你host主机(宿主)上的目录映射到Container里面,这样你就非常方便地在host主机上编辑代码,然后直接就可以在Container里面运行它们,而不用手动copy到Container里面再重启Container。按理将host的目录映射到guest(指Container)上应该是一件很容易的事情,就好像VMWare那样,但可惜的是,由于Mac上的Docker多了一层虚拟机,因此多了一层周折,你必须先VM上的目录通过sshfs mount到host(指Mac)上,然后再将你的目录或文件copy到这个mount的目录,再将VM上的这个目录映射到Container里,听起来比较拗口,画个图会清晰很多。

docker-disk-map

如上图所示,VM里面的/mnt/sda1/dev/目录(你需要自己创建)通过sshfs命令mount到了host主机(Mac)的~/workspace/dev/目录 ,而VM里的/mnt/sda1/dev/目录又被映射到了Container的/src/目录下,这样你就可以在Container里面的/src/目录下访问你的host文件了。具体如何做呢?首先你需要安装sshfs命令,然后将VM的password写到一个文件中,例如~/.boot2docker/b2d-passwd,在用sshfs命令mount起VM的/mnt/sda1/dev目录:

接着你在run一个Container的时候需要通过-v选项来将/mnt/sda1/dev/映射到/src目录:

这样你就可以在你的Container的/src目录下看到你host里的文件了。 磁盘映射还有2个地方需要注意:

  • 你的文件实际上是存储在VM里面的,也就是说你需要将你的目录或者文件copy到VM里面,你sshfs之后,就是copy到~/workspace/dev目录下
  • 千万不要sshfs mount非/mnt/sda1下的目录,因为VM里面跑的是TinyCoreLinux,这个OS的rootfs是临时性的(放在内存的,实际上就是boot2docker.iso文件里面的一个rootfs),因此其根目录/下的东西(包括/home)根本不会持久化,只有/mnt/sda1这个目录下的才能持久化。如果你放在/home目录下,只要VM一重启,就会丢失的,/mnt/sda1则不会,实际上就是那个~/.boot2docker-vm.vmdk文件挂载到了/mnt/sda1目录下

端口映射

和磁盘映射一样,你有时候会需要将Container的端口映射到host主机上,同样蛋疼的是,由于多了一层VM,端口映射也显得比较麻烦。首先你需要设置VirtualBox的端口映射,然后再将Container的端口映射到你的VM里面:

docker-port-map

具体是这么做的,通过2条命令:

也就是说在docker run的时候通过-p选项指定要映射的端口到VM,而boot2docker ssh命令则是将VM的8000端口映射到了host(Mac)的8000端口,这样你就可以通过Mac的localhost:8000访问Container的8000端口了。 其实,有另一种解决方案就是你不用映射到host(Mac),而是直接登录到VM里面进行访问就好了,boot2docker ssh就可以登录到VM,这样就类似于你的host是ubuntu,但这种解决方案的问题是这个ubuntu太弱了(TinyCoreLinux),如果你在这个ubuntu里面开发代码,或者是运行浏览器,是非常蛋疼的事情,关键还是这个ubuntu是每次重启都会复原的!所以我建议还是做多一层映射好了。 *后,实际上在VM里面,你是可以直接访问所有的Container的端口的,因为VM到Container的网络都是桥接的。

其他的一些坑

在使用的过程中,还遇到一些不少的坑:

  1. /etc/hosts文件无法修改,这样你就不能自己做域名解析
  2. VM的系统时间是UTC +0000的,而且貌似无法修改
  3. Container的IP无法指定为静态IP,因此每次重启Container时,IP可能会变化

第1个问题的解决方案是通过安装dnsmasq软件来做域名解析:

第2个问题的解决方案就稍微麻烦些,起码我没有找到更好的解决方案,我是将boot2docker.iso文件重新制作一次来解决这个问题的:

第三个问题暂时无法解决(可能需要编辑底层的LXC配置文件)。

docker的限制以及后续的一些想法

docker其实还是有一些限制的:

  • 要求你的环境是Linux的,而且内核必须很新(>= 2.6.27 (29)),这其实是LXC本身的限制,和docker无关
  • docker的Container目前host是不能修改的,当然有解决方案(dnsmasq)
  • docker的Container也暂时无法指定静态IP

用docker作为开发环境甚至是生产环境其实还有很多地方值得尝试:

  • 在团队内部构建本地的仓库,标准化所有的开发环境,使得团队的新人可以快速上手
  • 在生产环境部署docker,这其实是PAAS的虚拟化和自动化的一种方式,利用LXC和Docker能够更便捷地实施PAAS
  • 尝试用docker做分布式集群模拟和测试,成本会更加低廉,更加容器维

可能是把Docker的概念讲的*清楚的一篇文章

转载自:https://juejin.im/post/5b260ec26fb9a00e8e4b031a

本文只是对Docker的概念做了较为详细的介绍,并不涉及一些像Docker环境的安装以及Docker的一些常见操作和命令。

阅读本文大概需要15分钟,通过阅读本文你将知道一下概念:

  • 容器
  • 什么是Docker?
  • Docker思想、特点
  • Docker容器主要解决什么问题
  • 容器 VS 虚拟机
  • Docker基本概念: 镜像(Image),容器(Container),仓库(Repository)

Docker 是世界*的软件容器平台,所以想要搞懂Docker的概念我们必须先从容器开始说起。

一 先从认识容器开始

1.1 什么是容器?

先来看看容器较为官方的解释

一句话概括容器:容器就是将软件打包成标准化单元,以用于开发、交付和部署。

  • 容器镜像是轻量的、可执行的独立软件包 ,包含软件运行所需的所有内容:代码、运行时环境、系统工具、系统库和设置。
  • 容器化软件适用于基于Linux和Windows的应用,在任何环境中都能够始终如一地运行。
  • 容器赋予了软件独立性 ,使其免受外在环境差异(例如,开发和预演环境的差异)的影响,从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。

再来看看容器较为通俗的解释

如果需要通俗的描述容器的话,我觉得容器就是一个存放东西的地方,就像书包可以装各种文具、衣柜可以放各种衣服、鞋架可以放各种鞋子一样。我们现在所说的容器存放的东西可能更偏向于应用比如网站、程序甚至是系统环境。

 

认识容器

 

 

1.2 图解物理机、虚拟机与容器

关于虚拟机与容器的对比在后面会详细介绍到,这里只是通过网上的图片加深大家对于物理机、虚拟机与容器这三者的理解。

物理机

物理机

 

 

虚拟机:

 

虚拟机

 

 

容器:

 

容器

 

 

通过上面这三张抽象图,我们可以大概可以通过类比概括出: 容器虚拟化的是操作系统而不是硬件,容器之间是共享同一套操作系统资源的。虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统。因此容器的隔离级别会稍低一些。


相信通过上面的解释大家对于容器这个既陌生又熟悉的概念有了一个初步的认识,下面我们就来谈谈Docker的一些概念。

二 再来谈谈Docker的一些概念

 

Docker的一些概念

 

 

2.1 什么是Docker?

说实话关于Docker是什么并太好说,下面我通过四点向你说明Docker到底是个什么东西。

  • Docker 是世界*的软件容器平台。
  • Docker 使用 Google 公司推出的 Go 语言 进行开发实现,基于 Linux 内核 的cgroup,namespace,以及AUFS类的UnionFS等技术,对进程进行封装隔离,属于操作系统层面的虚拟化技术。 由于隔离的进程独立于宿主和其它的隔离的进 程,因此也称其为容器。Docke*初实现是基于 LXC.
  • Docker 能够自动执行重复性任务,例如搭建和配置开发环境,从而解放了开发人员以便他们专注在真正重要的事情上:构建杰出的软件。
  • 用户可以方便地创建和使用容器,把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改,就像管理普通的代码一样。

 

什么是Docker

 

 

2.2 Docker思想

  • 集装箱
  • 标准化: ①运输方式 ② 存储方式 ③ API接口
  • 隔离

2.3 Docker容器的特点

  • 轻量

    在一台机器上运行的多个 Docker 容器可以共享这台机器的操作系统内核;它们能够迅速启动,只需占用很少的计算和内存资源。镜像是通过文件系统层进行构造的,并共享一些公共文件。这样就能尽量降低磁盘用量,并能更快地下载镜像。

  • 标准

    Docker 容器基于开放式标准,能够在所有主流 Linux 版本、Microsoft Windows 以及包括 VM、裸机服务器和云在内的任何基础设施上运行。

  • 安全

    Docker 赋予应用的隔离性不仅限于彼此隔离,还独立于底层的基础设施。Docker 默认提供*强的隔离,因此应用出现问题,也只是单个容器的问题,而不会波及到整台机器。

2.4 为什么要用Docker

  • Docker 的镜像提供了除内核外完整的运行时环境,确保了应用运行环境一致性,从而不会再出现 “这段代码在我机器上没问题啊” 这类问题;——一致的运行环境
  • 可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。——更快速的启动时间
  • 避免公用的服务器,资源会容易受到其他用户的影响。——隔离性
  • 善于处理集中爆发的服务器使用压力;——弹性伸缩,快速扩展
  • 可以很轻易的将在一个平台上运行的应用,迁移到另一个平台上,而不用担心运行环境的变化导致应用无法正常运行的情况。——迁移方便
  • 使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。——持续交付和部署

每当说起容器,我们不得不将其与虚拟机做一个比较。就我而言,对于两者无所谓谁会取代谁,而是两者可以和谐共存。

三 容器 VS 虚拟机

简单来说: 容器和虚拟机具有相似的资源隔离和分配优势,但功能有所不同,因为容器虚拟化的是操作系统,而不是硬件,因此容器更容易移植,效率也更高。

3.1 两者对比图

传统虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统,在该系统上再运行所需应用进程;而容器内的应用进程直接运行于宿主的内核,容器内没有自己的内核,而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便.

 

容器 VS 虚拟机

 

 

3.2 容器与虚拟机 (VM) 总结

 

容器与虚拟机 (VM) 总结

 

 

  • 容器是一个应用层抽象,用于将代码和依赖资源打包在一起。 多个容器可以在同一台机器上运行,共享操作系统内核,但各自作为独立的进程在用户空间中运行 。与虚拟机相比, 容器占用的空间较少(容器镜像大小通常只有几十兆),瞬间就能完成启动 。
  • 虚拟机 (VM) 是一个物理硬件层抽象,用于将一台服务器变成多台服务器。 管理程序允许多个 VM 在一台机器上运行。每个VM都包含一整套操作系统、一个或多个应用、必要的二进制文件和库资源,因此 占用大量空间 。而且 VM 启动也十分缓慢 。

通过Docker官网,我们知道了这么多Docker的优势,但是大家也没有必要完全否定虚拟机技术,因为两者有不同的使用场景。虚拟机更擅长于彻底隔离整个运行环境。例如,云服务提供商通常采用虚拟机技术隔离不同的用户。而 Docker通常用于隔离不同的应用 ,例如前端,后端以及数据库。

3.3 容器与虚拟机 (VM)两者是可以共存的

就我而言,对于两者无所谓谁会取代谁,而是两者可以和谐共存。

 

两者是可以共存的

 

 


Docker中非常重要的三个基本概念,理解了这三个概念,就理解了 Docker 的整个生命周期。

四 Docker基本概念

Docker 包括三个基本概念

  • 镜像(Image)
  • 容器(Container)
  • 仓库(Repository)

理解了这三个概念,就理解了 Docker 的整个生命周期

 

Docker 包括三个基本概念

 

 

4.1 镜像(Image)——一个特殊的文件系统

操作系统分为内核和用户空间。对于 Linux 而言,内核启动后,会挂载 root 文件系统为其提供用户空间支持。而Docker 镜像(Image),就相当于是一个 root 文件系统。

Docker 镜像是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置等文件外,还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。 镜像不包含任何动态数据,其内容在构建之后也不会被改变。

Docker 设计时,就充分利用 Union FS的技术,将其设计为 分层存储的架构 。 镜像实际是由多层文件系统联合组成。

镜像构建时,会一层层构建,前一层是后一层的基础。每一层构建完就不会再发生改变,后一层上的任何改变只发生在自己这一层。 比如,删除前一层文件的操作,实际不是真的删除前一层的文件,而是仅在当前层标记为该文件已删除。在*终容器运行的时候,虽然不会看到这个文件,但是实际上该文件会一直跟随镜像。因此,在构建镜像的时候,需要额外小心,每一层尽量只包含该层需要添加的东西,任何额外的东西应该在该层构建结束前清理掉。

分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层,然后进一步添加新的层,以定制自己所需的内容,构建新的镜像。

4.2 容器(Container)——镜像运行时的实体

镜像(Image)和容器(Container)的关系,就像是面向对象程序设计中的 类 和 实例 一样,镜像是静态的定义,容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等 。

容器的实质是进程,但与直接在宿主执行的进程不同,容器进程运行于属于自己的独立的 命名空间。前面讲过镜像使用的是分层存储,容器也是如此。

容器存储层的生存周期和容器一样,容器消亡时,容器存储层也随之消亡。因此,任何保存于容器存储层的信息都会随容器删除而丢失。

按照 Docker *佳实践的要求,容器不应该向其存储层内写入任何数据 ,容器存储层要保持无状态化。所有的文件写入操作,都应该使用数据卷(Volume)、或者绑定宿主目录,在这些位置的读写会跳过容器存储层,直接对宿主(或网络存储)发生读写,其性能和稳定性更高。数据卷的生存周期独立于容器,容器消亡,数据卷不会消亡。因此, 使用数据卷后,容器可以随意删除、重新 run ,数据却不会丢失。

4.3 仓库(Repository)——集中存放镜像文件的地方

镜像构建完成后,可以很容易的在当前宿主上运行,但是, 如果需要在其它服务器上使用这个镜像,我们就需要一个集中的存储、分发镜像的服务,Docker Registry就是这样的服务。

一个 Docker Registry中可以包含多个仓库(Repository);每个仓库可以包含多个标签(Tag);每个标签对应一个镜像。所以说:镜像仓库是Docker用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。

通常,一个仓库会包含同一个软件不同版本的镜像,而标签就常用于对应该软件的各个版本 。我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签,将以 latest 作为默认标签.。

这里补充一下Docker Registry 公开服务和私有 Docker Registry的概念:

Docker Registry 公开服务 是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像,并可能提供收费服务供用户管理私有镜像。

*常使用的 Registry 公开服务是官方的 Docker Hub ,这也是默认的 Registry,并拥有大量的高质量的官方镜像,网址为:hub.docker.com/ 。在国内访问Docker Hub 可能会比较慢国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 时速云镜像库网易云镜像服务DaoCloud 镜像市场阿里云镜像库等。

除了使用公开服务外,用户还可以在 本地搭建私有 Docker Registry 。Docker 官方提供了 Docker Registry 镜像,可以直接使用做为私有 Registry 服务。开源的 Docker Registry 镜像只提供了 Docker Registry API 的服务端实现,足以支持 docker 命令,不影响使用。但不包含图形界面,以及镜像维护、用户管理、访问控制等高级功能。


Docker的概念基本上已经讲完,*后我们谈谈:Build, Ship, and Run。

五 *后谈谈:Build, Ship, and Run

如果你搜索Docker官网,会发现如下的字样:“Docker – Build, Ship, and Run Any App, Anywhere”。那么Build, Ship, and Run到底是在干什么呢?

 

build ship run

 

 

  • Build(构建镜像) : 镜像就像是集装箱包括文件以及运行环境等等资源。
  • Ship(运输镜像) :主机和仓库间运输,这里的仓库就像是超级码头一样。
  • Run (运行镜像) :运行的镜像就是一个容器,容器就是运行程序的地方。

Docker 运行过程也就是去仓库把镜像拉到本地,然后用一条命令把镜像运行起来变成容器。所以,我们也常常将Docker称为码头工人或码头装卸工,这和Docker的中文翻译搬运工人如出一辙。

六 总结

本文主要把Docker中的一些常见概念做了详细的阐述,但是并不涉及Docker的安装、镜像的使用、容器的操作等内容。这部分东西,希望读者自己可以通过阅读书籍与官方文档的形式掌握。如果觉得官方文档阅读起来很费力的话,这里推荐一本书籍《Docker技术入门与实战第二版》。

云计算为什么要学Docker容器 该怎样快速入门

云计算为什么要学Docker容器?该怎样快速入门?“云计算”作为未来网络甚至未来计算机行业的发展趋势,得到了广泛重视。越来越多的人想通过学习云计算收获高薪,很多人会发现学习云计算的过程中会接触到Docker容器,这究竟是为什么?如何快速高效的学好Docker容器、进而学好云计算呢?下面且看小编的分析。

%title插图%num

Docker是基于Linux 容器技术的开源项目,它使用Luinux的内核功能(如命名空间和控制组)在操作系统上创建容器。Docker容器具有四大优势:

1)使用简单:Docker 的口头禅是:“一次构建,处处运行”。它使得任何人(开发人员,运维,架构师和其他人)都可以更轻松的利用容器的优势来快速构建和测试可移植的应用程序。

2)速度:Docker容器非常轻量级和快速,因为容器只是运行在内核上的沙盒环境,因此它们占用的资源更少。与可能需要更多时间来创建的虚拟机相比,你可以在几秒钟内创建一个Docker容器。

3)Docker Hub:Docker Hub拥有数万个由社区构建的公共镜像,这些镜像都是随时可用的。Docker用户可以从日益丰富的Docker Hub生态中受益,可以把Docker Hub看作是“Docker 镜像的应用商店”。

4)模块化和可扩展性:Docker可以让你轻松地把应用程序按功能拆分为单个独立的容器。使用Docker,将这个容器链接在一起以创建你的应用程序将会变得更简单,同时在将来可以很轻松地扩展和更新单独的组件。

想要快速入门Docker容器技术,你需要了解Docker容器的安装与启动、镜像操作、应用部署、备份与迁移等知识。同时,Docker容器技术多是与云计算相结合,想要学好Docker找到好工作,参加专业的云计算培训班是明智的。

如何优雅使用Docker?请收下这15个小技巧

1

获取*近运行容器的id 这是我们经常会用到的一个操作,按照官方示例,你可以这样做(环境ubuntu):


$ ID=$(docker run ubuntu echo hello world) hello world $ docker commit $ID helloworld fd08a884dc79

这种方式在编写脚本的时候很有用,比如你想在脚本中批量获取id,然后进一步操作。但是这种方式要求你必须给ID赋值,如果是直接敲命令,这样做就不太方便了。 这时,你可以换一种方式:

  1. $ alias dl=’docker ps -l -q’
  2. $ docker run ubuntu echo hello world
  3. hello world
  4. $ dl
  5. 1904cf045887
  6. $ docker commit `dl` helloworld
  7. fd08a884dc79

docker ps -l -q命令将返回*近运行的容器的id,通过设置别名(alias),dl命令就是获取*近容器的id。这样,就无需再输入冗长的docker ps -l -q命令了。通过两个斜引号“,可以获取dl命令的值,也就是*近运行的容器的id。

2

尽量在Dockerfile中指定要安装的软件,而不用Docker容器的shell直接安装软件。 说实话,我有时候也喜欢在shell中安装软件,也许你也一样,喜欢在shell中把所有软件安装都搞定。但是,搞来搞去,*后还是发现,你还是需要在Doockerfile中指定安装文件。在shell中安装软件,你要这样做:

  1. $ docker run -i -t ubuntu bash #登陆到docker容器
  2. root@db0c3967abf8:/#

然后输入下面的命令来安装文件:

apt-get install postgresql

然后再调用exit:

root@db0c3978abf8:/# exit

退出docker容器,再给docker commit命令传递一个复杂的JSON字符串来提交新的镜像:

$ docker commit -run=”{“Cmd”:[“postgres”,”-too -many -opts”] }” `dl` postgres

太麻烦了,不是吗?还是在Dockerfile中指定安装文件吧,只要两个步骤:

  1. 1.在一个小巧的Dockerfile中,指定当前操作的镜像为FROM命令的参数
  2. 2.然后在Dockerfile中指定一些docker的命令,如CMD, ENTERPOINT, VOLUME等等来指定安装的软件

3

超-超-超级用户

你可能需要一直用超级用户来操作docker,就像早期示例里一直提示的:

  1. # 添加docker用户组
  2. $ sudo groupadd docker
  3. # 把自己加到docker用户组中
  4. $ sudo gpasswd -a myusername docker
  5. # 重启docker后台服务
  6. $ sudo service docker restart
  7. # 注销,然后再登陆
  8. $ exit

Wow!连续三个sudo!三次化身“超级用户”,真可谓是“超-超-超级用户”啊!别担心,设置完毕,以后你就再也不用打那么多sudo了!

4

清理垃圾

如果你想删除所有停止运行的容器,用这个命令:


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

顺便说一句,docker ps命令很慢,不知道为啥这么慢,按理说Go语言是很快的啊。docker ps -a -q命令列出所有容器的id,然后根据id删除容器。docker rm命令遇到正在运行的容器就会失效,所以这个命令完美的删除了所有没在运行的容器。

5

docker inspect输出结果的解析利器:jq 要对docker inspect的输出结果进行过滤,一般情况下,用grep命令,你需要这样操作:

$docker inspect `dl` | grep IPAddress | cut -d '"' -f 4 

哦!看上去很复杂,用jq吧,专业解析docker inspect输出结果,具有更强的可读性,方便易用:

$docker inspect `dl` | jq -r '.[0].NetworkSettings.IPAddress'

其中*个’.’代表所有的结果。’[0]’代表数组的*个元素。就像JavaScript访问一个JSON对象一样,简单方便。

6

镜像有哪些环境变量? 有时候,你需要知道自己创建的镜像有哪些环境变量。简单!只要这样:

$ docker run ubuntu env

输出结果如下:

  1. HOME=/
  2. PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  3. container=lxc
  4. HOSTNAME=5e1560b7f757

调用env查看环境变量,对于后面要讲到的“链接”(-link)很有用,在连接两个容器时候需要用到这些环境变量,具体请看*后一个要点“链接”。

7

RUN命令 vs CMD命令

Docker的新手用户比较容易混淆RUN和CMD这两个命令。 RUN命令在构建(Build)Docker时执行,这时CMD命令不执行。CMD命令在RUN命令执行时才执行。我们来理清关系,假设Dockerfile内容如下:

  1. FROM thelanddownunder
  2. MAINTAINER crocdundee

我们要向系统中安装一些软件,那么:

  1. # docker build将会执行下面的命令:
  2. RUN apt-get update
  3. RUN apt-get install softwares
  4. # dokcer run默认执行下面的命令:
  5. CMD [“softwares”]

Build时执行RUN,RUN时执行CMD,也就是说,CMD才是镜像*终执行的命令。

8

CMD命令 vs ENTRYPOINT命令

又是两条容易混淆的命令!具体细节我们就不说了,举个例子,假设一个容器的Dockerfile指定CMD命令,如下:

  1. FROM ubuntu
  2. CMD [“echo”]

另一个容器的Dockerfile指定ENTRYPOINT命令,如下:

  1. FROM ubuntu
  2. ENTRYPOINT [“echo”]

运行*个容器:

docker run image1 echo hello

得到的结果:

hello

运行第二个容器:

docker run image2 echo hello

得到的结果:

echo hello

看到不同了吧?实际上,CMD命令是可覆盖的,docker run后面输入的命令与CMD指定的命令匹配时,会把CMD指定的命令替换成docker run中带的命令。而ENTRYPOINT指定的命令只是一个“入口”,docker run后面的内容会全部传给这个“入口”,而不是进行命令的替换,所以得到的结果就是“echo hello”。

9

Docker容器有自己的IP地址吗?

刚接触Docker的人或许会有这样的疑问:Docker容器有自己的IP地址吗?Docker容器是一个进程?还是一个虚拟机?嗯…也许两者兼具?哈哈,其实,Docker容器确实有自己的IP,就像一个具有IP的进程。只要分别在主机和Docker容器中执行查看ip的命令就知道了。

查看主机的ip:

$ ip -4 -o addr show eth0

得到结果:

2: eth0 inet 162.243.139.222/24

查看Docker容器的ip:

$ docker run ubuntu ip -r -o addr show eth0

得到结果:

149: eth0   inet 172.17.0.43/16

两者并不相同,说明Docker容器有自己的ip。

10

基于命令行的瘦客户端,使用UNIX Socket和Docker后台服务的REST接口进行通信。Docker默认是用UNIX socket通信的,一直到大概0.5、0.6的版本还是用端口来通信,但现在则改成UNIX socket,所以从外部无法控制Docker容器的内部细节。下面我们来搞点有趣的事情,从主机链接到docker的UNIX socket:

  1. # 像HTTP客户端一样连接到UNIX socket
  2. $ nc -U / /var/run/docker.sock

连接成功后,输入:

GET /images/json HTTP/1.1

输入后连敲两个回车,第二个回车表示输入结束。然后,得到的结果应该是:

  1. HTTP/1.1 200 OK
  2. Content-Type: application/json
  3. Date: Tue, 05 Nov 2013 23:18:09 GMT
  4. Transfer-Encoding: chunked
  5. 16aa
  6. [{“Repository”:”postgres”,”Tag”:”……

有一天,我不小心把提交的名称打错了,名字开头打成”-xxx”(我把命令和选项的顺序搞混了),所以当我删除的时候出了问题,docker rm -xxx,会把-xxx当成参数而不是镜像的名称。所以我只得通过socket直接连到容器来调用REST Server把错误的东西删掉。

11

把镜像的依赖关系绘制成图

docker images命令有一个很拉风的选项:-viz,可以把镜像的依赖关系绘制成图并通过管道符号保存到图片文件:

  1. # 生成一个依赖关系的图表
  2. $ docker images -viz | dot -T png -o docker.png

这样,主机的当前路径下就生成了一张png图,然后,用python开启一个微型的HTTP服务器:

python -m SimpleHTTPServer

然后在别的机器上用浏览器打开:

http://machinename:8000/docker.png

OK,依赖关系一目了然!

(译者注:要使用dot命令,主机要安装graphviz包。另外,如果主机ip没有绑定域名,machinename换成主机的ip即可。)

12

Docker把东西都存到哪里去了? Docker实际上把所有东西都放到/var/lib/docker路径下了。切换成super用户,到/var/lib/docker下看看,你能学到很多有趣的东西。执行下面的命令:

  1. $ sudo su
  2. # cd /var/lib/docker
  3. # ls -F
  4. containers/ graph/ repositories volumes/

可以看到不少目录,containers目录当然就是存放容器(container)了,graph目录存放镜像,文件层(file system layer)存放在graph/imageid/layer路径下,这样你就可以看看文件层里到底有哪些东西,利用这种层级结构可以清楚的看到文件层是如 何一层一层叠加起来的。

13

Docker源代码:Go, Go, Go, Golang! Docker的源代码全部是用Go语言写的。Go是一门非常酷的语言。其实,不只是Docker,很多优秀的软件都是用Go写的。对我来说,Docker源文件中,有4个是我非常喜欢阅读的:

commands.go docker的命令行接口,是对REST API的一个轻量级封装。Docker团队不希望在命令中出现逻辑,因此commands.go只是向REST API发送指令,确保其较小的颗粒性。

api.go REST API的路由(接受commands.go中的请求,转发到server.go)

server.go 大部分REST API的实现

buildfile.go Dockerfile的解析器

有的伙计惊叹”Wow!Docker是怎么实现的?!我无法理解!”没关系,Docker是开源软件,去看它的源代码就可以了。如果你不太清楚Dockerfile中的命令是怎么回事,直接去看buildfile.go就明白了。

14

运行几个Docker后台程序,再退出容器,会发生什么? OK,倒数第二个要点。如果在Docker中运行几个后台程序,再退出Docker容器,会发生什么?答案是:不要这么做!因为这样做后台程序就全丢了。

Dockerfile中用RUN命令去开启一个后台程序,如:

RUN pg_ctl start

这样的话,RUN命令开启的后台程序就会丢失。调用容器的bash连到容器的shell:

$ docker run -i -t postgresimage bash

然后调用 ps aux查看进程,你会发现postgres的进程并没有跑起来。 RUN命令会影响文件系统。因此,不要再Dockerfile中用启动后台程序,要把后台程序启动成前台进程。或者,像一些高手提议的那样,写一个启动脚 本,在脚本中启动这些后台程序或进程。

15

容器之间进行友好沟通:链接

这是*拉风的功能!我把它留到*后压轴!这是0.6.5中*重要的新功能,我们前面已经提过两次了。运行一个容器,给它一个名称,在下面的例子中,我们通过-name参数给容器指定名称”loldb”:

$ docker run -d -name loldb loldbimage

再运行另一个容器,加上-link参数来连接到*个容器(别名为loldb),并给第二个容器也指定一个别名(这里用的是cheez):

$ docker run -link /loldb:cheez otherimage env

顺便得到cheez的环境变量:

  1. CHEEZ_PORT=tcp://172.17.0.8:6379
  2. CHEEZ_PORT_1337_TCP=tcp://172.17.0.8.6379
  3. CHEEZ_PORT_1337_TCP_ADDR=tcp://172.17.0.12
  4. CHEEZ_PORT_1337_TCP_PORT=6379
  5. CHEEZ_PORT_1337_TCP_PROTO=tcp

这样,我们就在两个容器间建立起一个网络通道(bridge),基于此,我们可以建立一个类似rails的程序:一个容器可以访问数据库容器而不对外暴露其他接口。非常酷!数据库容器只需要知道*个容器的别名(在本例中为cheez)和要打开的端口号。所以数据库容器也可以env命令来查看这个端口是否打开。

原文链接

www.cnblogs.com/elnino/p/3899136.html

学好Docker有哪些技巧

云计算人员要掌握什么?学好Docker有哪些技巧?Docker是轻量级容器管理引擎,它的出现为软件开发和云计算平台之间建立了桥梁,因此云计算人才必须要学习Docker容器技术。下面就给大家介绍一些Docker容器基础操作及学习技巧。

%title插图%num

Docker容器常见操作:

docker exec -it container_name bash 安装Docker

curl -sSL https://get.docker.com/ | sh 设置开机启动

systemctl enable docker 启动Docker

systemctl start docker 下载镜像

docker pull busybox ( image_name:version ) 删除镜像

docker rmi image_name:version 上传镜像

docker logindocker push username/app 创建容器

docker run -d -p 5000:5000 –restart=always –name registry -m 128m -v /data/registry:/var/lib/registry registry:2简单的版本

docker run -d -p 5000:5000 –name app nginx:1.11.1 更改镜像的tag

docker tag nginx your_name/nginx 对容器的一些操作

docker inspect app | grep -i memory ( 这里匹配内存的信息 ) 从容器创建一个镜像

docker save app > app.tar 从tar包恢复镜像

docker load < app.tar 在容器间分享数据

基于Linux平台上的多项开源技术,Docker提供了高效、敏捷和轻量级的容器方案,并支持部署到本地环境和多种主流云平台。可以说,Docker首次为应用的开发、运行和部署提供了“一站式”的实用解决方案。那么如何快速学好Docker呢?你可以参考以下几种方法:

首先你需要了解基本的理论知识,从简单命令行开始,了解Docker网络、了解如何创建Docker集群并使用编排系统、掌握基本的Docker概念和工具;随后你需要尝试着基于Docker做开发,过程中如果遇到什么问题,一定要不耻下问。如果你觉得自己自制力不行或者学习能力较差,*好是专业学习,这样既能快速学习理论知识,还可以积累较多的项目经验,一举多得。

用Docker之后还需要OpenStack吗

Docker从一个新兴的技术到一个商品化模式,这一过程的发展速度很惊人,它炙手可热的同时也给带来一些困惑。这也带来了一些同学的质疑和评论:假如用了Docker再去用OpenStack是否合适?本文来自Helion惠普云计算,深入浅出的对OpenStack和Docker进行类比。

以下是原文:

Solomon Hykes创立了Docker,没有想到过Docker会人气爆棚,成为仅次于OpenStack的*受欢迎的云开源项目。然而听说过Docker的朋友很少知道其真正的意义,很多人会被各种概念混淆,甚至把OpenStack和Docker进行类比。

Docker的相关背景

简单来说,Docker提供了一种程序运行的容器,同时保证这些容器相互隔离。虚拟机也有类似的功能,但是它通过Hypervisor创建了一个完整的操作系统栈。

不同于虚拟机的方式,Docker依赖于Linux自带的LXC(Linux Containers)技术。LXC利用了Linux可以对进程做内存、CPU、网络隔离的特性。Docker镜像不需要新启动一个操作系统,因此提供了一种轻量级的打包和运行程序的方式。而且Docker能够直接访问硬件,从而使它的I/O操作比虚拟机要快得多。

 

Docker可以直接跑在物理服务器上,这引起大家的疑问:假如已经用了Docker,还有必要使用OpenStack吗?

还有必要使用OpenStack吗?观点如下:

这个问题和OpenStack没有直接的联系,也可以套在其他云平台上。大家为什么会拿Docker和OpenStack做比较的原因是:OpenStack是私有云环境中*流行的云平台,在私有云环境中,大家认为可以把Docker作为另一种选择。

有关于Hypervisor的误区:很多KVM和Docker的性能测试的对比跟OpenStack一点关系都没有,因为OpenStack只是一种框架。事实上这种性能测试(不管是KVM还是Docker)是跑在OpenStack下,这表明了KVM和Docker可以共存。当使用OpenStack去管理Docker情况下,Docker和OpenStack的争论是没有意义的。

云平台提供一个完整管理数据中心的解决方案,至于用哪种hypervisor或container只是云平台中的一个小部分。像OpenStack这样的云平台包含了多租户的安全、隔离、管理、监控、存储、网络等其他部分。云数据中心的管理需要很多服务支撑,但这和用Docker还是KVM其实没多大关系。

Docker不是一个全功能的VM, 它有很多严重的缺陷,比如安全、Windows支持,因此不能完全替代KVM。现在Docker社区一直在弥补这些缺陷,当然这会带来一定的性能损耗。

原生hypervisor的性能、容器化的性能、应用的性能是不一样的东西,相互对比没有意义。

把Docker容器打包进KVM镜像中对Docker运行几乎没有影响。这种架构通常是用hypervisor来管理计算资源,而像Heat、Cloudify、Kubernetes这样的的orchestration layer都用于管理在hypervisor中的docker容器。

总结

正确看待OpenStack、KVM、Docker的方式应该是: OpenStack用于管理整个数据中心,KVM和Docker作为相应的补充,KVM用于多租户的计算资源管理,Docker Container用于应用程序的打包部署。

Centos与Ubuntu中安装docker

ubuntu系统
1.更新包索引

sudo apt-get update

2.安装以下包使apt可以通过HTTPS使用存储库(repository)

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

3.添加Docker的官方GPG密钥

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –

4.安装stable存储库

sudo add-apt-repository “deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable”

5.更新apt包索引

sudo apt-get update

6.安装Docker CE

sudo apt-get install docker-ce

7.测试hello world

sudo docker run hello-world

docker服务一般安装完成后自启,不放心的话
查看docker服务是否启动

systemctl status docker

若未启动,则启动docker服务

sudo systemctl start docker

如果想要安装特定版本 可以查看系统支持版本

apt-cache madison docker-ce

选择要安装的特定版本,第二列是版本字符串,第三列是存储库名称,它指示包来自哪个存储库,以及扩展它的稳定性级别。
要安装一个特定的版本,将版本字符串附加到包名中,并通过等号(=)分隔它们

sudo apt-get install docker-ce=<VERSION>

卸载之前版本(之前如果安装过)

sudo apt-get remove docker docker-engine docker-ce docker.io

Centos系统
1.*新yum 包

sudo yum update

2.安装需要的软件包

sudo yum install -y yum-utils \
device-mapper-persistent-data \
lvm2

3.设置yum源

sudo yum-config-manager \
–add-repo \
https://download.docker.com/linux/centos/docker-ce.repo

4.安装docker

sudo yum install docker-ce docker-ce-cli containerd.io

5.启动并测试hello world

sudo systemctl start docker

sudo docker run hello-world

6.设置docker自启

sudo systemctl enable docker

sudo chkconfig docker on

如果要安装一个特定的版本
查看仓库中所有docker版本

yum list docker-ce –showduplicates | sort -r

安装docker,其中<VERSION_STRING>替换成相应的版本号,版本号为第二列,替换成(docker-ce-18.09.1)

sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io

卸载之前版本(之前如果安装过)

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

如果上述方法有错误请指正谢谢
如果使用上述方法安装不成功请检查 系统的内核是否支持docker 及时更换Linux系统版本

友情链接: SITEMAP | 旋风加速器官网 | 旋风软件中心 | textarea | 黑洞加速器 | jiaohess | 老王加速器 | 烧饼哥加速器 | 小蓝鸟 | tiktok加速器 | 旋风加速度器 | 旋风加速 | quickq加速器 | 飞驰加速器 | 飞鸟加速器 | 狗急加速器 | hammer加速器 | trafficace | 原子加速器 | 葫芦加速器 | 麦旋风 | 油管加速器 | anycastly | INS加速器 | INS加速器免费版 | 免费vqn加速外网 | 旋风加速器 | 快橙加速器 | 啊哈加速器 | 迷雾通 | 优途加速器 | 海外播 | 坚果加速器 | 海外vqn加速 | 蘑菇加速器 | 毛豆加速器 | 接码平台 | 接码S | 西柚加速器 | 快柠檬加速器 | 黑洞加速 | falemon | 快橙加速器 | anycast加速器 | ibaidu | moneytreeblog | 坚果加速器 | 派币加速器 | 飞鸟加速器 | 毛豆APP | PIKPAK | 安卓vqn免费 | 一元机场加速器 | 一元机场 | 老王加速器 | 黑洞加速器 | 白石山 | 小牛加速器 | 黑洞加速 | 迷雾通官网 | 迷雾通 | 迷雾通加速器 | 十大免费加速神器 | 猎豹加速器 | 蚂蚁加速器 | 坚果加速器 | 黑洞加速 | 银河加速器 | 猎豹加速器 | 海鸥加速器 | 芒果加速器 | 小牛加速器 | 极光加速器 | 黑洞加速 | movabletype中文网 | 猎豹加速器官网 | 烧饼哥加速器官网 | 旋风加速器度器 | 哔咔漫画 | PicACG | 雷霆加速