①
# yum groupinstall -y "Development Tools"
# yum -y install epel-release #需要安装python-pip的扩展源
# yum -y install python-dev* libevent-dev* python-pip* openssl-devel xz-devel libffi-dev*
# [root@docker1 ~]# git clone https://github.com/docker/docker-registry.git
Cloning into 'docker-registry'...
remote: Counting objects: 7007,done.
remote: Total 7007 (delta 0),reused 0 (delta 0),pack-reused 7007
Receiving objects: 100% (7007/7007),1.69 MiB | 334.00 KiB/s,done.
Resolving deltas: 100% (4099/4099),done.
# cd docker-registry
# ls
ADVANCED.md CHANGELOG.md config CONTRIBUTING.md depends docker_registry FAQ.md MANIFEST.in requirements setup.cfg tests AUTHORS circle.yml contrib DEBUGGING.md Dockerfile DRIVERS.md LICENSE README.md scripts setup.py tox.ini
② 然后基于样例创建配置文件：
# cp config/config_sample.yml config/config.yml
修改local模版段的storage_path到本地的存储仓库的路径，例如：/tmp/registry更改为/opt/data/registry。
# vi config/config.yml
......
local: &local
<<: *common
storage: local
storage_path: _env:STORAGE_PATH:/opt/data/registry
......
③ 需要安装M2Crypto RSA加密、解密
1.手动安装 M2Crypto 0.22.3
# wget https://pypi.python.org/packages/source/M/M2Crypto/M2Crypto-0.22.3.tar.gz #下载源码
# tar zxvf M2Crypto/M2Crypto-0.22.3.tar.gz # 解压
# cd M2Crypto-0.22.3

2. 然后创建安装脚本，内容如下:
# vim fedora_setup.sh
#!/bin/sh
# This script is meant to work around the differences on Fedora Core-based# distributions (Redhat,CentOS,...) compared to other common Linux
# distributions.
#
# Usage: ./fedora_setup.sh [setup.py options]
#

arch=`uname -m`
for i in SWIG/_{ec,evp}.i; do
sed -i -e "s/opensslconf\./opensslconf-${arch}\./" "$i"
done

SWIG_FEATURES=-cpperraswarn python setup.py $*

3. 然后为脚本添加执行权限，执行脚本，并安装M2Crypto 0.22.3
# chmod +x fedora_setup.sh
# ./fedora_setup.sh build
# python setup.py install
# echo $? #返回值为0，则安装成功

解决方法是在docker的配置文件里面OPTIONS添加 –insecure-registryhttp://10.0.0.10:5000选项
# /etc/sysconfig/docker

# Modify these options if you want to change the way the docker daemon runs
OPTIONS='--selinux-enabled --insecure-registry 10.0.0.10:5000'
DOCKER_CERT_PATH=/etc/docker
然后重启docker服务：
systemctl restart docker



④ 然后执行安装操作：
# python setup.py install
# echo $? #返回值为0，则安装成功
对于通过软件包方式安装的，配置文件一般需要放在
/usr/local/lib/python2.7/dist-packages/docker_registry/config/cpnfig.yml

⑤ 此时，可以通过下面的命令来启动(nohup commend &; jobs -l查看进程)：
# gunicorn --access-logfile /var/log/docker-registry/access.log --error-logfile /var/log/docker-registry/server.log -k gevent --max-requests 100 --graceful-timeout 3600 -t 3600 -b 127.0.0.1:5000 -w 1 docker_registry.wsgi:application
# curl 127.0.0.1:5000

⑥ 配置服务脚本：
一般通过服务脚本来管理registry服务会更加方便，以centos系统为例：
首先，创建/etc/init/docker-registry.conf文件，内容为：

首先在/lib/systemd/system/目录下，创建服务脚本：docker-registry.service

[root@docker1 ~]# cd /etc/init
init.d/ inittab

[root@docker1 init.d]# ./docker-registry
[root@docker1 init.d]# nohup: appending output to ‘nohup.out’
^C
[root@docker1 init.d]# cat docker-registry
#!/bin/bash
#description "Docker Registry"

nohup gunicorn --access-logfile /var/log/docker-registry/access.log --error-logfile /var/log/docker-registry/server.log -k gevent --max-requests 100 --graceful-timeout 3600 -t 3600 -b localhost:15000 -w 8 docker_registry.wsgi:application &
然后，执行./docker-registry，将在本地的15000端口启动registry服务。


2) 用户认证：
通常在生产场景中，对私有仓库还需要进行访问代理和提供认证和用户管理。
① 配置Nginx代理
使用Nginx来代理registry服务的原理十分简单，在上一节中，我们让registry服务监听在127.0.0.1:15000，这意味着只允许本机才能通过15000端口访问到，其他主机是无法访问到的。
为了让其他主机访问到，可以通过Nginx监听在对外地址的5000端口，当外部访问请求到达5000端口时，内部再将请求转发到本地的15000端口。
首先，安装Nginx。
# yum -y install Nginx

通过Nginx配置docker-registry反向代理
[root@docker1 ~]# cat /etc/Nginx/Nginx.conf
# For Nginx < 1.3.9
# FYI: Chunking requires Nginx-extras package on Debian Wheezy and some Ubuntu versions
# See chunking http://wiki.Nginx.org/HttpChunkinModule
# Replace with appropriate values where necessary

user Nginx;
worker_processes 10;

error_log /var/log/Nginx/error.log warn;
pid /var/run/Nginx.pid;


events {
worker_connections 1024;
}


http {
#本地的registry服务监听在15000端口
upstream docker-registry {
server 127.0.0.1:15000;
}

# uncomment if you want a 301 redirect for users attempting to connect
# on port 80
# NOTE: docker client will still fail. This is just for convenience
# server {
# listen *:80;
# server_name my.docker.registry.com;
# return 301 https://$server_name$request_uri;
# }

server {
#代理服务器监听在5000端口
listen 5000;
server_name my.docker.registry.com;

# ssl on; #注释三行
# ssl_certificate /etc/ssl/certs/docker-registry;
# ssl_certificate_key /etc/ssl/private/docker-registry;

proxy_set_header Host $http_host; #required for Docker client sake #添加这两行
proxy_set_header X-Real-IP $remote_addr; #pass on real client IP

client_max_body_size 0; # disable any limits to avoid HTTP 413 for large image uploads

chunked_transfer_encoding on;

location / {
#配置转发对于"/"的访问请求到registry服务
proxy_pass http://docker-registry;
}

location /_ping {
#配置转发对于/ping的访问请求到registry服务
auth_basic off;
proxy_pass http://docker-registry;
}

location /v1/_ping {
#配置转发对于/v1/ping的访问请求到registry服务
auth_basic off;
proxy_pass http://docker-registry;
}
}
}
之后，可以通过上传镜像来测试服务是否正常。测试上传本地的sshd:centos镜像：
[root@docker1 ~]# curl 127.0.0.1:15000
"\"docker-registry server\""
[root@docker1 ~]# curl 127.0.0.1:5000
"\"docker-registry server\""

[root@docker1 ~]# docker tag docker.io/Nginx 127.0.0.1:5000/Nginx:latest
[root@docker1 ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
127.0.0.1:5000/Nginx latest ae513a47849c 7 days ago 108.9 MB
docker.io/Nginx latest ae513a47849c 7 days ago 108.9 MB
[root@docker1 ~]# docker push 127.0.0.1:5000/Nginx:latest
The push refers to a repository [127.0.0.1:5000/Nginx:latest]
7ab428981537: Image successfully pushed
82b81d779f83: Image successfully pushed
d626a8ad97a1: Image successfully pushed
Pushing tag for rev [ae513a47849c] on {http://127.0.0.1:5000/v1/repositories/Nginx.latest/tags/latest}


② 添加用户认证
公共仓库DockerHub是通过注册索引(index)服务来实现的。由于index服务并没有完善的开源实现，在这里介绍基于Nginx代理的用户访问管理方案。
Nginx支持基于用户名和密码的访问管理。
首先，在配置文件的location/字段中添加两行。
[root@docker1 ~]# vi /etc/Nginx/Nginx.conf
......
location / {
#let Nginx know about our auth file
auth_basic "Please Input username/password"; #注意不要丢了分号
auth_basic_user_file docker-registry-htpasswd;

proxy_pass http://docker-registry;
}
......
-----------------------------------------------------------------
auth_basic "Please Input username/password" 行说明了启用认证服务，不通过的请求将无法转发。
auth_basic_user_file docker-registry-htpasswd;指定了验证的用户名密码存储文件为本地(/etc/Nginx/下)的docker-registry-htpasswd文件。
docker-registry-htpasswd文件中存储用户名密码的格式为每行放一个用户名、密码对：
...
user1:password1
user2:password2
...
需要注意的是，密码字段存储的并不是明文，而是使用crypt函数加密过的字符串。
要生成加密后的字符串，可以通过htpasswd工具 (apache密码生成工具htpasswd的应用)，首先安装apache2-utils:
# yum install -y httpd-tools

创建用户user1，并添加密码
例如，如下的操作会创建/etc/Nginx/docker-registrt-htpasswd文件来保存用户名和加密后的密码信息，并创建user1和对应密码。
[root@docker1 ~]# htpasswd -c /etc/Nginx/docker-registry-htpasswd user1
New password:
Re-type new password:
Adding password for user user1
添加更多用户，可以重复上面的命令(密码文件存在后，不需使用-c选项重新创建)。
[root@docker1 ~]# htpasswd /etc/Nginx/docker-registry-htpasswd user2
New password:
Re-type new password:
Adding password for user user2
[root@docker1 ~]# cat /etc/Nginx/docker-registry-htpasswd
user1:$apr1$Ou2YtwCo$zDFLKHCZwWasX9owaU5il/
user2:$apr1$.amOaUuK$aHIDR/72ZvZUNNSWavdku/
最后，重新启动Nginx服务。
此时，通过浏览器访问本地的服务http://127.0.0.1:5000/v1/search，会弹出对话框，提示输入用户名和密码。
[root@docker1 ~]# curl 127.0.0.1:5000
<html>
<head><title>401 Authorization required</title></head>
<body bgcolor="white">
<center><h1>401 Authorization required</h1></center>
<hr><center>Nginx/1.14.0</center>
</body>
</html>
[root@docker1 ~]# curl 127.0.0.1:5000/v1/search
<html>
<head><title>401 Authorization required</title></head>
<body bgcolor="white">
<center><h1>401 Authorization required</h1></center>
<hr><center>Nginx/1.14.0</center>
</body>
</html>
通过命令行访问，需要在地址前面带上用户名和密码才能正常返回：
[root@docker1 ~]# curl user1:user1@localhost:5000/v1/search
{"num_results": 2,"query": "","results": [{"description": "","name": "library/Nginx.latest"},{"description": "","name": "library/Nginx"}]

3) 使用私有仓库批量上传镜像
在前面对Docker私有仓库的讲解中，介绍了如何使用本地私有仓库进行上传、下载等操作。有时候，本地镜像很多，逐个打标记上传将十分浪费时间。这里给出两个自动化脚本，来快速完成对大量镜像的上传操作。
① 批量上传指定镜像
可以使用下面的push_images.sh脚本，批量上传本地的镜像到注册服务器中，默认是本地注册服务器127.0.0.1:5000，用户可以通过修改registry=127.0.0.1:5000这行来指定目标注册服务器:


[root@docker1 bin]# docker login -u user1 -p user1 127.0.0.1:5000 #登录docker-registry
Login Succeeded
[root@docker1 bin]# ./push_images.sh sshd:centos 这一步的认证有问题

The registry server is 127.0.0.1:5000
Uploading sshd:centos...
The push refers to a repository [127.0.0.1:5000/sshd]
1313b4282620: Waiting
4665eb546397: Waiting
5fe984cfc360: Waiting
f2bd4f252713: Waiting
b53eaab8551b: Waiting
2935bd02b7fe: Waiting
cf5686344c89: Waiting
c7d53387d4f7: Waiting
c800d514f009: Waiting
1c5890b2b229: Waiting
c460848e3502: Waiting
ccc941d601ab: Waiting
1a8c6d0f3b9f: Waiting
57a2e3e43348: Waiting
cf516324493c: Pushing
Authentication is required.
Untagged: 127.0.0.1:5000/sshd:centos
Done


建议把脚本存放到本地的可执行路径下，例如/usr/local/bin/下面。
然后添加可执行权限，就可以使用该脚本了：


② 批量上传本地所有镜像
在push_images工具的基础上，还可以进一步的创建push_all工具，来上传本地所有镜像：
[root@docker1 bin]# cat push_all.sh
#!/bin/bash

for image in `docker images |grep -v "REPOSTIORY" |grep -v "<none>" |awk '{print $1":"$2}'`
do
push_images.sh $image
done
同样，读者把它放在/usr/local/bin下面，并添加可执行权限，之后就可通过push_all.sh命令上传本地所有镜像到本地私有仓库中了。


4) 仓库配置文件
Docker的Registry利用配置文件提供了一些仓库的模版(flavor)，用户可以直接使用它们来进行开发或生产部署。
我们将以下面的示例配置为例，来介绍如何使用仓库配置文件来管理私有仓库。

示例配置：
[root@docker1 ~]# cat /root/docker-registry/config/config_sample.yml
# All other flavors inherit the `common' config snippet
common: &common
issue: '"docker-registry server"'
# 默认记录info和以上级别的日志
loglevel: _env:LOGLEVEL:info
# 是否启用debug模式
debug: _env:DEBUG:false
# 默认是standalone模式，不查询index服务
standalone: _env:STANDALONE:true
# 非standalone模式下的index服务默认是index.docker.io
index_endpoint: _env:INDEX_ENDPOINT:https://index.docker.io
# 默认不启用存储转向
storage_redirect: _env:STORAGE_REDIRECT
# 非standalone模式下启用基于口令串的认证
disable_token_auth: _env:DISABLE_TOKEN_AUTH
# 默认不使用特权
privileged_key: _env:PRIVILEGED_KEY
# 搜索后端支持
search_backend: _env:SEARCH_BACKEND
# sqlite搜索后端数据库地址
sqlalchemy_index_database: _env:sqlALCHEMY_INDEX_DATABASE:sqlite:////tmp/docker-registry.db

# 默认不启用镜像服务
mirroring:
source: _env:MIRROR_SOURCE # https://registry-1.docker.io
source_index: _env:MIRROR_SOURCE_INDEX # https://index.docker.io
tags_cache_ttl: _env:MIRROR_TAGS_CACHE_TTL:172800 # seconds

cache:
host: _env:CACHE_REDIS_HOST
port: _env:CACHE_REDIS_PORT
db: _env:CACHE_REDIS_DB:0
password: _env:CACHE_REDIS_PASSWORD

# 访问远端存储后端时，配置LRU缓存
cache_lru:
host: _env:CACHE_LRU_REDIS_HOST
port: _env:CACHE_LRU_REDIS_PORT
db: _env:CACHE_LRU_REDIS_DB:0
password: _env:CACHE_LRU_REDIS_PASSWORD

# 发生异常时发送邮件通知
email_exceptions:
smtp_host: _env:SMTP_HOST
smtp_port: _env:SMTP_PORT:25
smtp_login: _env:SMTP_LOGIN
smtp_password: _env:SMTP_PASSWORD
smtp_secure: _env:SMTP_SECURE:false
from_addr: _env:SMTP_FROM_ADDR:docker-registry@localdomain.local
to_addr: _env:SMTP_TO_ADDR:noise+dockerregistry@localdomain.local

# 启用bugsnag
bugsnag: _env:BUGSNAG

# CORE支持，默认未启用
cors:
origins: _env:CORS_ORIGINS
methods: _env:CORS_METHODS
headers: _env:CORS_HEADERS:[Content-Type]
expose_headers: _env:CORS_EXPOSE_HEADERS
supports_credentials: _env:CORS_SUPPORTS_CREDENTIALS
max_age: _env:CORS_MAX_AGE
send_wildcard: _env:CORS_SEND_WILDCARD
always_send: _env:CORS_ALWAYS_SEND
automatic_options: _env:CORS_AUTOMATIC_OPTIONS
vary_header: _env:CORS_VARY_HEADER
resources: _env:CORS_RESOURCES

local: &local
<<: *common
storage: local
storage_path: _env:STORAGE_PATH:/tmp/registry


s3: &s3
<<: *common
storage: s3
s3_region: _env:AWS_REGION
s3_bucket: _env:AWS_BUCKET
boto_bucket: _env:AWS_BUCKET
storage_path: _env:STORAGE_PATH:/registry
s3_encrypt: _env:AWS_ENCRYPT:true
s3_secure: _env:AWS_SECURE:true
s3_access_key: _env:AWS_KEY
s3_secret_key: _env:AWS_SECRET
s3_use_sigv4: _env:AWS_USE_SIGV4
boto_host: _env:AWS_HOST
boto_port: _env:AWS_PORT
boto_calling_format: _env:AWS_CALLING_FORMAT

cloudfronts3: &cloudfronts3
<<: *s3
cloudfront:
base: _env:CF_BASE_URL
keyid: _env:CF_KEYID
keysecret: _env:CF_KEYSECRET

azureblob: &azureblob
<<: *common
storage: azureblob
azure_storage_account_name: _env:AZURE_STORAGE_ACCOUNT_NAME
azure_storage_account_key: _env:AZURE_STORAGE_ACCOUNT_KEY
azure_storage_container: _env:AZURE_STORAGE_CONTAINER:registry
azure_use_https: _env:AZURE_USE_HTTPS:true

# Ceph对象网关配置
ceph-s3: &ceph-s3
<<: *common
storage: s3
s3_region: ~
s3_bucket: _env:AWS_BUCKET
s3_encrypt: _env:AWS_ENCRYPT:false
s3_secure: _env:AWS_SECURE:false
storage_path: _env:STORAGE_PATH:/registry
s3_access_key: _env:AWS_KEY
s3_secret_key: _env:AWS_SECRET
boto_bucket: _env:AWS_BUCKET
boto_host: _env:AWS_HOST
boto_port: _env:AWS_PORT
boto_debug: _env:AWS_DEBUG:0
boto_calling_format: _env:AWS_CALLING_FORMAT

# Google 云存储配置
gcs:
<<: *common
storage: gcs
boto_bucket: _env:GCS_BUCKET
storage_path: _env:STORAGE_PATH:/registry
gs_secure: _env:GCS_SECURE:true
gs_access_key: _env:GCS_KEY
gs_secret_key: _env:GCS_SECRET
# 存储服务的OAuth 2.0认证
oauth2: _env:GCS_OAUTH2:false

# 存储镜像文件到Openstack Swift服务
swift: &swift
<<: *common
storage: swift
storage_path: _env:STORAGE_PATH:/registry
# keystone authorization
swift_authurl: _env:OS_AUTH_URL
swift_container: _env:OS_CONTAINER
swift_user: _env:OS_USERNAME
swift_password: _env:OS_PASSWORD
swift_tenant_name: _env:OS_TENANT_NAME
swift_region_name: _env:OS_REGION_NAME

# 存储镜像文件到Open Stack Glance服务
glance: &glance
<<: *common
storage: glance
storage_alternate: _env:GLANCE_STORAGE_ALTERNATE:file
storage_path: _env:STORAGE_PATH:/tmp/registry

openstack:
<<: *glance

# 存储镜像文件到Glance，标签信息到Swift
glance-swift: &glance-swift
<<: *swift
storage: glance
storage_alternate: swift

openstack-swift:
<<: *glance-swift

elliptics:
<<: *common
storage: elliptics
elliptics_nodes: _env:ELLIPTICS_NODES
elliptics_wait_timeout: _env:ELLIPTICS_WAIT_TIMEOUT:60
elliptics_check_timeout: _env:ELLIPTICS_CHECK_TIMEOUT:60
elliptics_io_thread_num: _env:ELLIPTICS_IO_THREAD_NUM:2
elliptics_net_thread_num: _env:ELLIPTICS_NET_THREAD_NUM:2
elliptics_nonblocking_io_thread_num: _env:ELLIPTICS_NONBLOCKING_IO_THREAD_NUM:2
elliptics_groups: _env:ELLIPTICS_GROUPS
elliptics_verbosity: _env:ELLIPTICS_VERBOSITY:4
elliptics_logfile: _env:ELLIPTICS_LOGFILE:/dev/stderr
elliptics_addr_family: _env:ELLIPTICS_ADDR_FAMILY:2

# This flavor stores the images in Aliyun OSS
# See:
# https://i.aliyun.com/access_key/
# for details on access and secret keys.
oss: &oss
<<: *common
storage: oss
storage_path: _env:STORAGE_PATH:/registry/
oss_host: _env:OSS_HOST
oss_bucket: _env:OSS_BUCKET
oss_accessid: _env:OSS_KEY
oss_accesskey: _env:OSS_SECRET



# 默认启用的配置选项
dev: &dev
<<: *local
loglevel: _env:LOGLEVEL:debug
debug: _env:DEBUG:true
search_backend: _env:SEARCH_BACKEND:sqlalchemy

# 用于测试
test:
<<: *dev
index_endpoint: https://registry-stage.hub.docker.com
standalone: true
storage_path: _env:STORAGE_PATH:./tmp/test

# 在环境变量SETTINGS_FLAVOR中指定启用哪个配置，例如$ export SETTINGS_FLAVOR=prod
prod:
<<: *s3
storage_path: _env:STORAGE_PATH:/prod


模版
在config_sample.yml文件中，可以看到一些现成的模版段：
◆ common: 基础配置
◆ local: 存储数据到本地文件系统
◆ s3: 存储数据到AWS S3中
◆ dev: 使用local模版的基本配置
◆ test: 单元测试使用。
◆ prod: 生产环境配置(基本上跟s3配置)
◆ gcs: 存储数据到Google的云存储
◆ swift: 存储数据到OpenStack Swift服务
◆ glance: 存储数据到OpenStack Glance服务，本地文件系统为后备
◆ glance-swift: 存储数据到OpenStack Glance服务，Swift为后备。
◆ elliptics: 存储数据到Elliptics key/value存储
用户也可以添加自定义的模版段。
默认情况下使用的模版是dev，要使用某个模版作为默认值，可以添加SETTINGS_FLAVOR到环境变量中，例如：
export SETTINGS_FLAVOR=dev
另外，配置文件中支持从环境变量中加载值，语法格式为:
_env:VARIABLENAME[:DEFALUT]

选项
○ 基本选项如下：
◆ loglevel: 字符串类型，标注输出调试信息的级别，包括debug、info、warn、error和critical。
◆ debug: 布尔类型，开启后会在访问/_ping时候输出更多的信息，包括库版本和主机信息等。
◆ storage_redirect：重定向存储请求。
◆ boto_host/boto_port: 使用s3模版时，标准boto配置文件的位置。

○ 搜索选项如下：
Docker注册服务器可以将仓库的索引信息放到数据库中，供通过GET方法访问/v1/search时使用。
◆ search_backend: 选择搜索后端类型，目前仅支持sqlalchemy。用户也可以将它指定为自定义的模版。例如：
common:
search_backend: foo.registry.index.xapian
◆ sqlalchemy_index_database: 当使用sqlalchemy作为索引后端引擎时，可以通过sqlalchemy_index_database来指定创建数据库的位置。例如：
common:
search_backend: sqlalchemy
sqlalchemy_index_database: sqlite:///tmp/docker-registry.db
○ 镜像选项都放在mirroring字段下面，例如：
common:
mirroring:
source: https://registry-1.docker.io
source_index: https://index.docker.io
tags_cache_ttl: 172800 # 2 days
默认并未启用。
○ 缓存选项包括cache字段和cache_lru字段，例如：
cache:
host: _env:CACHE_REDIS_HOST
port: _env:CACHE_REDIS_PORT
db: _env:CACHE_REDIS_DB:0
password: _env:CACHE_REDIS_PASSWORD

# 访问远端存储后端时，配置LRU缓存
cache_lru:
host: _env:CACHE_LRU_REDIS_HOST
port: _env:CACHE_LRU_REDIS_PORT
db: _env:CACHE_LRU_REDIS_DB:0
password: _env:CACHE_LRU_REDIS_PASSWORD
通过配置缓存(事先本地要启动一个LRU模式下的redis服务器)，可以将小文件缓存在本地，加速仓库的查询性能。
○ Email选项为email_exceptions字段，通过配置该选项，当仓库发生异常时自动发送Email。例如：
# 发生异常时发送邮件通知
email_exceptions:
smtp_host: _env:SMTP_HOST
smtp_port: _env:SMTP_PORT:25
smtp_login: _env:SMTP_LOGIN
smtp_password: _env:SMTP_PASSWORD
smtp_secure: _env:SMTP_SECURE:false
from_addr: _env:SMTP_FROM_ADDR:docker-registry@localdomain.local
to_addr: _env:SMTP_TO_ADDR:noise+dockerregistry@localdomain.local
○ 存储选项为storage，该选项将选择事先存储的引擎，仓库默认自带两种类型的引擎：file和s3。用户如果需要其他引擎支持，可以通过下面的命令来进行搜索可用引擎并安装。
# pip search docker-registry-driver
# pip install docker-registry-driver-NAME
安装后，可能需要对引擎进行配置。目前支持的引擎包括：
○ elliptics (一种分布式键值数据存储)
○ swift (OpenStack的子项目，提供对象存储服务)
○ gcs (Google的子存储)
○ glance (OpenStack的子项目，提供文件存储服务)
° file引擎
file引擎意味着存储到本地文件。当使用file引擎的时候，可以通过storage_path来指定存储的具体位置，以local模版为例，默认为/tmp/registry。
local: &local
<<: *common
storage: local
storage_path: _env:STORAGE_PATH:/tmp/registry
因此，我们在运行registry镜像时，可以挂载本地目录到这个位置，来保存仓库中的数据到本地，即
# docker run -p 5000 -v /tmp/registry:/tmp/registry registry

° s3引擎
s3引擎意味着存储到亚马逊的云服务。亚马逊s3引擎支持的选项包括：
○ s3_access_key: 字符串类型，s3的访问口令
○ s3_secret_key：字符串类型，s3密钥
○ s3_bucket: 字符串类型，s3桶名称
○ s3_region: s3桶所在的存放域
○ s3_encrypt: 布尔类型，是否加密存储
○ s3_secure: 布尔类型，进行访问时是否启用HTTPS
○ boto_bucket: 字符串类型，对s3不兼容对象存储的桶名
○ boto_host: 字符串类型，对s3不兼容对象存储的主机。
○ boto_port: 对s3不兼容对象存储的端口
○ boto_debug: 对s3不兼容对象存储的调试输出
○ boto_calling_format: 字符串类型，boto调用所使用格式的类名。
○ storage_path: 字符串类型，镜像文件存储的子路径。
例如：
prod:
storage: s3
s3_region: us-west-1
s3_bucket: acme-docker
storage_path: /registry
s3_access_key: AKIAHSHAKJSKKJJSKAJK
s3_secret_key:xasdkj289bdsbhasbjhckncskl

附：

M2Crypto-0.22.3.tar.gz http://down.51cto.com/data/2446591