若把一台Linxu机器比喻为一艘船，那么每一个Linux Container就好比船上的一个集装箱。

另外一个层面，Docker Image(镜像)就是一个预先定义行为的模板，Docker Container(容器)是镜像模板运行时的状态。一个镜像模板，可以对应N个容器实例运行时。 Docker号称，(镜像)一处构建，到处运行(Container)，这不是当初Java的口号嘛！无论是工作机，还是线上服务器，

一个具体的Docker镜像就好比一张画板，你在上面画什么，你们就会形成新的模板，可以循环利用。

Docker可用于测试，可用于沙箱隔离，可用于运行桌面，可用于作为数据/Web服务存在，总之作为一个较为完整的抽象的技术堆栈模板，好比打开了一扇窗，给予了人们若干种可能性，无限的想象空间。

构建一个Redis as a Service镜像

设定企业内部，每一个系统都需要独享Redis缓存服务，这不就是SAAS软件即服务的适用场景嘛,若基于Docker上构建，那是相当的简单。使用Docker脚本构建Redis服务镜像模板，那是相当的简单：

redis.dockerfile：

FROM        ubuntu:12.10
RUN         apt-get update
RUN         apt-get -y install redis-server
EXPOSE      6379
ENTRYPOINT  ["/usr/bin/redis-server"]

接着构建镜像：

docker build -t yongboy/redis -< redis.dockerfile

当然，你可以使用dns服务来通过内部域名进行路由定位，这里简略。

运行时设置某一个Redis Server具体实例:

docker run -name redis1_server -d -p 192.168.190.133:7001:6379 -m 1g yongboy/redis

这里指定当前运行的实例名称为redis1_server，分配1G内存，以后台进程服务方式运行，同时端口映射到宿主机持有第二个IP地址192.168.190.133和端口7001上。执行上面命令，会收到当前内核不支持交换分区的警告信息，这里直接无视好了：

WARNING: Your kernel does not support memory swap capabilities. Limitation discarded.

在宿主技术上安装redis客户端，测试一下，确认可以连接到redis1_server服务器上：

telnet 192.168.190.133 7001
Trying 192.168.190.133...
Connected to 192.168.190.133.
Escape character is '^]'.
set docker awesome
+OK
get docker
$7
awesome
get redis
$-1

redis1_server在运行中，输入 ctrl + ]，输入q退出telnet。

运行更多的Redis镜像实例:

docker run -name redis2_server -d -p 192.168.190.133:7002:6379 -m 1g yongboy/redis
docker run -name redis3_server -d -p 192.168.190.133:7003:6379 -m 1g yongboy/redis
docker run -name redis4_server -d -p 192.168.190.133:7004:6379 -m 1g yongboy/redis
docker run -name redis5_server -d -p 192.168.190.133:7005:6379 -m 1g yongboy/redis

宿主机只有4G内存，那么每一个Redis Sever都会自动分配1G内存，运行5个实例，出现了资源超售现象：

yongboy@localhost:~$ docker ps
CONTAINER ID        IMAGE                  COMMAND                CREATED             STATUS              PORTS                            NAMES
9b9d3f5fceb8        yongboy/redis:latest   /usr/bin/redis-serve   2 seconds ago       Up 1 seconds        192.168.190.133:7005->6379/tcp   redis5_server       
caf413606999        yongboy/redis:latest   /usr/bin/redis-serve   4 seconds ago       Up 3 seconds        192.168.190.133:7004->6379/tcp   redis4_server       
76566b33469a        yongboy/redis:latest   /usr/bin/redis-serve   4 seconds ago       Up 4 seconds        192.168.190.133:7003->6379/tcp   redis3_server       
4e24a529c5fc        yongboy/redis:latest   /usr/bin/redis-serve   4 seconds ago       Up 4 seconds        192.168.190.133:7002->6379/tcp   redis2_server       
5e3d9536948a        yongboy/redis:latest   /usr/bin/redis-serve   19 minutes ago      Up 19 minutes       192.168.190.133:7001->6379/tcp   redis1_server

在每一个容器实例实际占用内存都达到或接近1G时，会出现内存申请出现失败情况。实际环境中，这个是需要尽量避免资源超售的。

在不考虑资源超售或理想情况下，一台服务服务器最多可虚拟多少个Redis Server容器实例呢，这个跟网络资源有关。

服务器对外暴露地址(IP:Port)为二元组，理论上一台Linux Server可以使用的端口数量为65535个(去除常用的端口设为可用端口有65000个)，本机可以绑定的IP数量 * 可用端口数量 = 单机最大可以对外提供的服务器接口地址，即Redis Server实例。这些有些无聊了 ：))

小结

虽然Docker到现在还没有释出1.0版，但基于Docker构建私有还是公有的Service，业界已经给予了很好的一份答案。

国内已经有百度使用Docker构建自己的商用PAAS平台，详见Baidu using Docker for its PaaS。当然了，国内其它PAAS提供商也都在暗中使劲。

http://www.tsuru.io/的开发者贡献的tsuru and docker文档，很好的说明了他们如何使用Docker搭建完整的PAAS平台一些实践事宜，包括DNS/路由、各种独立SAAS、服务发现等，在架构上还是很清晰的。

嗯，有机会，想测测Docker中容器的性能如何。

Docker的文件系统AUFS，一种“增量文件系统”，用户所做修改以增量的方式保存，决定了其分层存储特性。

最顶层为读写层，初始将无内容，后续创建文件将会保存于此。若依赖层(亦即较低层)需要更新文件，那么更新后的文件将被保存在最顶层。总之，除了最顶层，所有底层都不可写。较低层总是被其它镜像共享。总之，Docker仅仅需要记录最顶层容器所有改变即可，这部分可以做到版本更迭、增量式存储，设计思路很赞！

Docker如何持久化状态

其实，我很关心Docker运行中的容器实例，如何保存状态。

运行中的Docker容器实例首先会在当前内存中持有一些状态信息，其次文件系统都会发生或多或少的改变。当前Docker能够支持哪些持久化，下面一一列出。

1. 容器实例因意外出现退出，如何持久化这种情况，人为使用 'docker commit'，也是不错的方法。但有人提出了更好的方式，通过捕捉退出信号，不妨一试。

   trapping signal from “docker stop” in bash

   docker-exec项目

2. 容器实例的挂起/恢复当前Docker不支持容器的挂起/恢复操作，但可参考一下原生的LXC内置命令lxc-freeze/lxc-unfreeze和CRIU(http://criu.org/Main_Page)：

   consider a docker suspend and resume

   Can I suspend and then resume Docker container?

   目前最期待Docker和CRIU的整合工作有待进展，可能会促进Docker商业化更进一步。

3. 挂载宿主机目录 Docker支持挂载宿主机目录，支持宿主机目录和容器之间文件目录进行映射，彼此共享:

   docker run -i -t -v /host/dir:/container/path ubuntu /bin/bash
   

   在Dockerfile中，则可以使用'VOLUME'命令

   VOLUME ["/var/volume1", "/var/volume2"] 
   

4. 如何在容器之间共享存储 容器之间文件目录(数据卷)可分享、重用，主要借助于'-volumes-from'参数实现。

   COUCH1=$(sudo docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
   COUCH2=$(sudo docker run -d -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
   

   这个特性，可引入很大的想象空间。若，一个Container实例用于Web存储，另外两个实例负载用于处理应用请求，分分离离，降低耦合。

5. 镜像导入/导出构建的镜像，作为一种状态存在，支持很方便的导入导出。导出：

   docker save IMAGENAME | bzip2 -9 -c>img.tar.bz2
   

   导入镜像：

   bzip2 -d -c <img.tar.bz2 | docker load
   

小结

目前Docker对运行中容器内存状态持久化不支持，仅限于文件层面的持久化支持等。通过挂载宿主机目录，把变化部分mount过来即可，减少docker commit次数，实现动静态分离。

更多信息，可参考：Share Directories via Volumes

在第一篇文字中，我们完全人工方式，一个命令一个命令输入，实现一个java tomcat运行环境，虽然也初见成效，但很累人。如果依靠依靠脚本构建一个Tomcat容器实例，一个命令可以搞定，何乐而不为呢。好在Docker提供了Dockerfile作为构建Docker镜像脚本，避免人们一行一行的输入，真是善莫大焉。Dockerfile脚本可以做到随时维护修改，即可以分享，更有利于在模板化，更不用说传输了，好处那是一大箩筐！

最终目的：打造一个支持SSH终端登录、Tomcat7自动运行的Docker镜像。

编写一个Dockerfile

所有环境，同第一篇文字。在ubuntu下安装好vim之后（吐槽一下，ubuntu系统内置vi命令十分难用，只好求助于vim )：

sudo vim Dockerfile

编辑一个Dockerfile文件了，下面就是具体文件内容：

# VERSION 0.0.1
# 默认ubuntu server长期支持版本，当前是12.04
FROM ubuntu
# 签名啦
MAINTAINER yongboy "yongboy@gmail.com"

# 更新源，安装ssh server
RUN echo "deb http://archive.ubuntu.com/ubuntu precise main universe"> /etc/apt/sources.list
RUN apt-get update
RUN apt-get install -y openssh-server
RUN mkdir -p /var/run/sshd

# 设置root ssh远程登录密码为123456
RUN echo "root:123456" | chpasswd 

# 添加orache java7源，一次性安装vim，wget，curl，java7，tomcat7等必备软件
RUN apt-get install python-software-properties
RUN add-apt-repository ppa:webupd8team/java
RUN apt-get update
RUN apt-get install -y vim wget curl oracle-java7-installer tomcat7

# 设置JAVA_HOME环境变量
RUN update-alternatives --display java
RUN echo "JAVA_HOME=/usr/lib/jvm/java-7-oracle">> /etc/environment
RUN echo "JAVA_HOME=/usr/lib/jvm/java-7-oracle">> /etc/default/tomcat7

# 容器需要开放SSH 22端口
EXPOSE 22

# 容器需要开放Tomcat 8080端口
EXPOSE 8080

# 设置Tomcat7初始化运行，SSH终端服务器作为后台运行
ENTRYPOINT service tomcat7 start && /usr/sbin/sshd -D

需要注意：

1. ENTRYPOINT，表示镜像在初始化时需要执行的命令，不可被重写覆盖，需谨记
2. CMD，表示镜像运行默认参数，可被重写覆盖
3. ENTRYPOINT/CMD都只能在文件中存在一次，并且最后一个生效 多个存在，只有最后一个生效，其它无效！
4. 需要初始化运行多个命令，彼此之间可以使用 && 隔开，但最后一个须要为无限运行的命令，需切记！

ENTRYPOINT/CMD，一般两者可以配合使用，比如：

ENTRYPOINT ["/usr/sbin/sshd"]
CMD ["-D"]

在Docker　daemon模式下，无论你是使用ENTRYPOINT，还是CMD，最后的命令，一定要是当前进程需要一直运行的，才能够防容器退出。

以下无效方式：

 ENTRYPOINT service tomcat7 start #运行几秒钟之后，容器就会退出
 CMD service tomcat7 start #运行几秒钟之后，容器就会退出

这样有效：

ENTRYPOINT service tomcat7 start && tail -f /var/lib/tomcat7/logs/catalina.out
# 或者
CMD service tomcat7 start && tail -f /var/lib/tomcat7/logs/catalina.out

这样也有效：

 ENTRYPOINT ["/usr/sbin/sshd"]
 CMD ["-D"]

具体请参考官方文档：Dockerfiles for Images

构建镜像

脚本写好了，需要转换成镜像：

docker build -t yongboy/java7 .

-t： 为构建的镜像制定一个标签，便于记忆/索引等

. ： 指定Dockerfile文件在当前目录下

网速不太好，会等待很长时间。很多操作可能需要科学上网，逼得我只能一直挂着VPN，方能畅通无阻。

构建镜像完成之后，看看运行效果：

docker run -d -p 22 -p 8080:8080 yongboy/java7

在运行命令中，还得需要显式指定 -p 22 -p 8080:8080，否则在Docker 0.8.1版本中不会主动映射到宿主机上。据悉在Docker 0.4.8版本时，就不担心这个问题。 或者，您要有好的方式，不妨告知于我，谢谢。

在Dockerfile中，若没有使用ENTRYPOINT/CMD指令，若运行多个命令，可以这样做：

docker run -d -p 22 -p 8080 yongboy/java7 /bin/sh -c "service tomcat7 start && /usr/sbin/sshd -D"

提交/保存镜像

创建好的镜像，可以保存到索引仓库中，便于下次使用（当然，我们直接共享Dockerfile，是最简单的事情，:)) ），但毕竟镜像可以做到开箱即用。

1. https://index.docker.io/ 注册一个账号，例如yongboy

2. 构建镜像

   docker build -t yongboy/java7 .
   

   上面已经构建OK的话，可省略此步。

3. 登陆

   docker login
   

4. 提交到Docker索引仓库

   docker push yongboy/java7
   

   现在可以起来喝杯热水，出去溜达会，也不一定能够上传完毕，那叫一个慢啊！

   上传OK的话，可以得到类似地址：https://index.docker.io/u/yongboy/java7/

5. 如何使用镜像

   docker pull yongboy/java7
   

   剩下的步骤，就很简单了。

小结

有关Dockerfile的进阶阅读：

• http://www.docker.io/learn/dockerfile/level2/
• http://www.docker.io/learn/dockerfile/level2/

以上蜻蜓点水一般，更多细节，请阅读官方文档。 若有空，在下篇中，讨论一下Docker的一些机制等。 嗯，最近失业了，您如有心，可以帮忙推荐一下，谢谢。

Docker旨在提供一种应用程序的自动化部署解决方案，在 Linux 系统上迅速创建一个容器（轻量级虚拟机）并部署和运行应用程序，并通过配置文件可以轻松实现应用程序的自动化安装、部署和升级，非常方便。因为使用了容器，所以可以很方便的把生产环境和开发环境分开，互不影响，这是 docker 最普遍的一个玩法。更多的玩法还有大规模 web 应用、数据库部署、持续部署、集群、测试环境、面向服务的云计算、虚拟桌面 VDI 等等。

主观的印象：Docker 使用 Go 语言编写，用 cgroup 实现资源隔离，容器技术采用 LXC. 提供了能够独立运行Unix进程的轻量级虚拟化解决方案。它提供了一种在安全、可重复的环境中自动部署软件的方式。LXC命令有些复杂，若感兴趣，这里有一篇我以前写的基于LXC，（从无到有，搭建一个简单版的JAVA PAAS云平台），可以提前复习一下。

有关实现原理、相关理论、运用场景等，会在本系列后面书写，这里先来一个浅尝辄止，完全手动，基于Docker搭建一个Tomcat运行环境。先出来一个像模像样Demo，可以见到效果，可能会让我们走的更远一些。

环境

本文所有环境，VMware WorkStation上运行ubuntu-13.10-server-amd64,注意是64位系统，理论上其它虚拟机也是完全可行的。

安装Docker

Docker 0.7版本需要linux内核 3.8支持，同时需要AUFS文件系统。

# 检查一下AUFS是否已安装
sudo apt-get update
sudo apt-get install linux-image-extra-`uname -r`
# 添加Docker repository key
sudo sh -c "wget -qO- https://get.docker.io/gpg | apt-key add -" 
# 添加Docker repository，并安装Docker
sudo sh -c "echo deb http://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list"
sudo apt-get update
sudo apt-get install lxc-docker
# 检查Docker是否已安装成功
sudo docker version
# 终端输出 Client version: 0.7.1
Go version (client): go1.2
Git commit (client): 88df052
Server version: 0.7.1
Git commit (server): 88df052
Go version (server): go1.2
Last stable version: 0.7.1

去除掉sudo

在Ubuntu下，在执行Docker时，每次都要输入sudo，同时输入密码，很累人的，这里微调一下，把当前用户执行权限添加到相应的docker用户组里面。

# 添加一个新的docker用户组
sudo groupadd docker
# 添加当前用户到docker用户组里，注意这里的yongboy为ubuntu server登录用户名
sudo gpasswd -a yongboy docker
# 重启Docker后台监护进程
sudo service docker restart
# 重启之后，尝试一下，是否生效
docker version
#若还未生效，则系统重启，则生效
sudo reboot

安装一个Docker运行实例-ubuntu虚拟机

Docker安装完毕，后台进程也自动启动了，可以安装虚拟机实例（这里直接拿官方演示使用的learn/tutorial镜像为例）：

docker pull learn/tutorial

安装完成之后，看看效果

docker run learn/tutorial /bin/echo hello world

交互式进入新安装的虚拟机中

docker run -i -t learn/tutorial /bin/bash

会看到：

root@51774a81beb3:/# 

说明已经进入交互式环境。

安装SSH终端服务器，便于我们外部使用SSH客户端登陆访问

apt-get update
apt-get install openssh-server
which sshd
/usr/sbin/sshd
mkdir /var/run/sshd
passwd #输入用户密码，我这里设置为123456，便于SSH客户端登陆使用
exit #退出

获取到刚才操作的实例容器ID

#docker ps -l
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
51774a81beb3 learn/tutorial:latest /bin/bash 3 minutes ago Exit 0 thirsty_pasteur

可以看到当前操作的容器ID为：51774a81beb3。注意了，一旦进行所有操作，都需要提交保存，便于SSH登陆使用：

docker commit 51774a81beb3 learn/tutorial

以后台进程方式长期运行此镜像实例：

docker run -d -p 22 -p 80:8080 learn/tutorial /usr/sbin/sshd -D

ubuntu容器内运行着的SSH Server占用22端口，-p 22进行指定。-p 80:8080 指的是，我们ubuntu将会以8080端口运行tomcat，但对外（容器外）映射的端口为80。

这时，查看一下，是否成功运行。

#docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
871769a4f5ea learn/tutorial:latest /usr/sbin/sshd -D About a minute ago Up About a minute 0.0.0.0:49154->22/tcp, 0.0.0.0:80->8080/tcp focused_poincare

注意这里的分配随机的SSH连接端口号为49154：

ssh root@127.0.0.1 -p 49154

输入可以口令，是不是可以进入了？你一旦控制了SSH，剩下的事情就很简单了，安装JDK，安装tomcat等，随你所愿了。以下为安装脚本：

# 在ubuntu 12.04上安装oracle jdk 7
apt-get install python-software-properties
add-apt-repository ppa:webupd8team/java
apt-get update
apt-get install -y wget
apt-get install oracle-java7-installer
java -version
# 下载tomcat 7.0.47
wget http://mirror.bit.edu.cn/apache/tomcat/tomcat-7/v7.0.47/bin/apache-tomcat-7.0.47.tar.gz
# 解压，运行
tar xvf apache-tomcat-7.0.47.tar.gz
cd apache-tomcat-7.0.47
bin/startup.sh

默认情况下，tomcat会占用8080端口，刚才在启动镜像实例的时候，指定了 -p 80:8080，ubuntu镜像实例/容器，开放8080端口，映射到宿主机端口就是80。知道宿主机IP地址，那就可以自由访问了。在宿主机上，通过curl测试一下即可：

curl http://192.168.190.131

当然，你也可以使用浏览器访问啦。

真实情况，可能不会让tomcat直接对外开放80端口，一般都会位于nginx/apache或者防火墙的后面，上面仅为演示。

小结

在Docker帮助下搭建一个Tomcat运行时环境，总体很简单，让我们看到了PAAS的身影。不错，使用Docker作为PAAS底层服务，本身就不复杂。 下面有时间，会谈一谈如何使用脚本文件构建一个镜像实例，同时会谈一谈Docker的实现原理和机制等。

CoreOS宣称最小化的定制版linux系统，具有：

• Linux内核，Linux运行所需
• 存在两个ROOT分区，一个被用作启动分区，一个被用作更新分区
  更新分区在更新完成后，自动重新启动系统，当前机器不需要从负载集群中移除，为了保证其它应用程序不被打断，会通过Linux cgroup限制更新过程中的磁盘、网络等IO使用。

• systemd，作为默认系统和服务管理器，其优秀特性：

  支持并行化任务；
  同时采用 socket 式与 D-Bus 总线式激活服务；
  按需启动守护进程（daemon）；
  利用 Linux 的 cgroups 监视进程；
  支持快照和系统恢复；
  维护挂载点和自动挂载点；
  各服务间基于依赖关系进行精密控制。
  

• root分区被设计成只读，用以保证数据的一致性和更新可用

• CPU、IO等资源隔离，自然要祭出容器(Container)来，CoreOS很明智使用Docker作为容器管理器用以构建、发布应用，从这个层面来看，一个应用其实就是一个容器。
• etcd组件负责服务发现和配置共享，采用Raft分布式一致性协议算法，承担起，组件之间服务通信使用。很自然的，容器(Container)之间应用、服务的伸缩，就显得很简单了。其基因层面支持集群特性，当然，你也可以解读为云环境的支持。

看起来，这个系统是为类似于拥有众多平台的IT公司准备的。服务之间，粒度变得很细。

刚刚发布第一个0.1.0版本，官方总结特性如下：

1. 接口简单，HTTP+JSON
2. 安全，可选择的SSL通信协议
3. 快速，经测试1000s单一实例写入操作
4. 可靠，分布式层面使用Raft协议
5. 坚固，集群的失败可以从磁盘恢复

要想体验，目前看来，最简单方式，需要在一个虚拟环境中尝试一把，当然也是这样做的。本次体验，基于Windows 7 64位系统。以下为简单步骤：

1. 先安装VirtualBox 4.2.16，建议从官网下载。
2. Vagrant，这次安装最新的1.2.7版本，下载地址
3. 安装Git for Windows 1.8.3,可以让命令下直接使用git命令

4. 安装CoreOS环境，打开windows命令行环境：

   git clone https://github.com/coreos/coreos-vagrant/
   cd coreos-vagrant
   vagrant up
   vagrant ssh
   

   执行完毕 vagrant ssh, 会自动生成一些ssh的一些信息：

   Host: 127.0.0.1
   Port: 2222
   Username: core
   Private key: C:/Users/nieyong/.vagrant.d/insecure_private_key
   

   使用熟悉的SSH终端工具登陆即可，这里推荐xshell，不在细述。SSH成功登入，可以看到欢迎信息：

   

5. 体验一把Docker作为容器管理器
   这里快速体验一把，敲入一下命令：

   docker run ubuntu /bin/echo hello world
   

   此时，自动下载Ubuntu系统容器镜像文件：

   

   更多Docker操作，请参阅其文档。

6. 进程管理systemd的一处使用这里想让系统启动时，执行一些简单任务。终端下输入

   sudo -i
   

   切换到Ubuntu ROOT用户角色下， 执行vi /media/state/units/hello.service，敲入如下内容：

   [Unit]
   Description=My Service
   After=docker.service
   
   [Service]
   Restart=always
   ExecStart=/usr/bin/docker run ubuntu /bin/sh -c "while true; do echo Hello World; sleep 1; done"
   
   [Install]
   WantedBy=local.target
   

   保存之后，我们需要做到模拟重启：

   systemctl restart local-enable.service
   

   现在查看一下日志，可以看到其输出：

   journalctl -u hello.service -f
   

   

   更多systemd细节，请参考http://www.freedesktop.org/wiki/Software/systemd/。

7. 本次浅尝辄止，到此结束

总体看，CoreOS最大特色，专门为大规模服务器部署定制的Linux精简系统，尽可能的精简无关紧要的功能，将操作系统和应用程序完全分离，从而降低操作系统和应用程序的耦合度，同时解决了现有Linux服务器在容器资源、权限管理方面的欠缺。目前若说是颠覆性的操作系统，十分牵强，是不是未来，也不好说，但肯定是一种趋势。

因此，十分值得期待。

进阶阅读：

忙碌的人可以就此略过，有闲的人，可以浪费些空闲，看一看无关痛痒的文字。

实时Web，一般人可以玩得起，只要你具有一些JAVA编程知识，外加一些JS实践，也不是难事。

这里，简单设计一个基于socketio-netty的实时Web数据驱动平台，用以托管实时应用，同时也提供了前后端的设计思路，从中也可以看到多租户架构一些影子。

至于什么是Firebase，什么是socketio-netty，那就只有自行ｇｏｏｇｌｅ。

设计思路

后端设计

1. 一个应用实例对应一个IOHandler接口实现
2. 用户上传实现代码，初始化一个应用实例，产生一个API KEY
3. API KEY 客户端需要显示引用；API KEY是应用实例一一对应关系
4. 服务器端提供java class 的hotswap（热部署），应用实例动态添加/删除/替换，做到无缝、平滑
5. 暂时不考虑文件系统等，功能为先

socketio-netty支持多个namespace（或许称为频道更为合适）的添加，静态加载示范：

前端实践

1. 一个页面，支持多个应用实例，支持多个API KEY
2. 前端JS须定义
   

   <script src="http://domain.com/yourfirebase.js"></script>

3. API KEY使用方式和原生的socket.io客户端使用方式一模一样，无须多言。

WEB端管理维护

再来一个用户的系统后台管理就完备了：

1. 上传JAVA接口实现代码，前期可只允许上传.java代码，以便代码监测使用（私有，则不需要）
2. 查看应用实例，重新生成API KEY等
3. 实例维护，暂停/停止/升级/替换/添加等，无缝、平滑等
4. 其它常规操作

设计小结

基础功做好之后，很显然，您已经实现了一个多租户架构的实时WEB数据驱动平台（名头有些大哈），托管第三方实时应用，有点PAAS的味道。虽然针对的应用很窄，但更专业了。

至于计费，安全，权限等，暂时可以歇歇，想太多，走不了多远，太累，反而成就感会降低。系统进化演进的，大而全，不如小而精。

这中间，难免需要对socketio-netty做一些定制工作，以适应应用实例的管理工作。

至于实际应用，需要注意的地方还很多，这里不过是一个简单模型（去掉了非核心的部分）的描述，和Firebase没有半毛钱的关系。

虽然设计了，不知道实际有没有人需要这个东西，希望不是空中楼阁。

PS/碎碎语

socketio-netty最近的一些进展（与上面设计不相关）:

1. 增加示范在线演示
   入口地址：http://socketio.yongboy.com/
   在线聊天示范 访问
   在线画板示范 访问
   
   想了解socket.io或者想了解socketio-netty的，可以点击一下。
   但愿别超出EC2的免费流量限额，可能随时会关闭。
2. 增加使用者名单
   http://code.google.com/p/socketio-netty/wiki/UsersCollections
   
   至少，目前已经有一家公司使用于生产环境