如何用Docker重新定义Java虚拟化部署

如何用Docker重新定义Java虚拟化部署,相信很多没有经验的人对此束手无策,为此本文总结了问题出现的原因和解决方法,通过这篇文章希望你能解决这个问题。

创新互联专注于确山企业网站建设,响应式网站建设,商城建设。确山网站建设公司,为确山等地区提供建站服务。全流程专业公司,专业设计,全程项目跟踪,创新互联专业和态度为您提供的服务

今天就和大家分享在docker里部署java应用的实战案例。

>>>Dockerfiles

Dockerfile包含了一系列指令,告诉Docker如何去构建一个镜像,它指定了镜像的基点,以及配置镜像的每个细节。以下是一个Dockerfile示例,是CentOS镜像的Dockerfile。

代码清单1. CentOS Dockerfile

```sh
FROM scratch
MAINTAINER The CentOS Project  - ami_creator
ADD centos-7-20150616_1752-docker.tar.xz /
# Volumes for systemd
# VOLUME ["/run", "/tmp"]
# Environment for systemd
# ENV container=docker
# For systemd usage this changes to /usr/sbin/init
# Keeping it as /bin/bash for compatibility with previous
CMD ["/bin/bash"]
```

大部分内容是注释,主要有四句命令:
1. FROM scratch:所有Dockerfile都要从一个基础镜像继承,在这个例子中,CentOS镜像是继承于"scratch"镜像,这个镜像是所有镜像的根。这个配置是固定的,表明了这个是Docker的根镜像之一。
2. MAINTAINER ...MAINTAINER指令指明了镜像的所有者,这个例子中所有者是CentOS Project。
3. ADD centos...tar.xzADD指令告诉Docker把指定文件上传到镜像中,如果文件是压缩过的,会把它解压到指定路径。这个例子中,Docker会上传一个CentOS操作系统的Gzip包,并解压到系统的根目录。
4. CMD ["/bin/bash"]:最后,CMD指令告诉Docker要执行什么命令,这个例子中,最后会进入Bourne Again Shell (bash)终端。
现在你知道Docker大概是长什么样子了,接下来再看看Tomcat官方的Dockerfile,图2说明了这个文件的架构。

如何用Docker重新定义Java虚拟化部署

这个架构未必如你想象中那么简单,但我们接下来会慢慢学习它,其实它是非常有逻辑的。上边已经提过所有Dockerfile的根是scratch,接下来指定的是debian:jessie镜像,这个官方镜像是基于标准镜像构建的,Docker不需要重复发明轮子,每次都创建一个新镜像了,只要基于一个稳定的镜像来继续构建新镜像即可,在这个例子中,debian:jessie是一个官方Debian Linux镜像,就像上边的CentOS一样,它只有三行指令。

代码清单 2. debian:jessie Dockerfile

```sh
FROM scratch
ADD rootfs.tar.xz /
CMD ["/bin/bash"]
```

在上图中我们还见到有安装两个额外的镜像,CURL 和 Source Code Management,镜像buildpack-deps:jessie-curl的Dockerfile如清单3所示。

代码清单 3. buildpack-deps:jessie-curl Dockerfile

```sh
FROM debian:jessie
RUN apt-get update && apt-get install -y --no-install-recommends \
  ca-certificates \
  curl \
  wget \
 && rm -rf /var/lib/apt/lists/*
```

这个Dockerfile中使用apt-get去安装curlwget,使这个镜像能从其他服务器下载软件。RUN指令让Docker在运行的实例中执行具体的命令,这个例子中,它会更新所有库(apt-get update),然后执行apt-get install去安装curlwget

buildpack-deps:jessie-scp的Dockerfile如清单4所示.

代码清单 4. buildpack-deps:jessie-scp Dockerfile

```sh
FROM buildpack-deps:jessie-curl
RUN apt-get update && apt-get install -y --no-install-recommends \
  bzr \
  git \
  mercurial \
  openssh-client \
  subversion \
 && rm -rf /var/lib/apt/lists/*
```

这个[Dockerfile]会安装源码管理工具,例如Git,Mercurial, 和 Subversion。

Java的[Dockerfile会更加复杂些,如清单5所示。

代码清单 5. Java Dockerfile

```sh
FROM buildpack-deps:jessie-scm
# A few problems with compiling Java from source:
#  1. Oracle.  Licensing prevents us from redistributing the official JDK.
#  2. Compiling OpenJDK also requires the JDK to be installed, and it gets
#       really hairy.

RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
RUN echo 'deb  jessie-backports main' > /etc/apt/sources.list.d/jessie-backports.list
# Default to UTF-8 file.encoding
ENV LANG C.UTF-8
ENV JAVA_VERSION 8u66
ENV JAVA_DEBIAN_VERSION 8u66-b01-1~bpo8+1
# see

# and

ENV CA_CERTIFICATES_JAVA_VERSION 20140324
RUN set -x \
 && apt-get update \
 && apt-get install -y \
  openjdk-8-jdk="$JAVA_DEBIAN_VERSION">  ca-certificates-java="$CA_CERTIFICATES_JAVA_VERSION" \
 && rm -rf /var/lib/apt/lists/*
# see CA_CERTIFICATES_JAVA_VERSION notes above
RUN /var/lib/dpkg/info/ca-certificates-java.postinst configure
# If you're reading this and have any feedback on how this image could be
#   improved, please open an issue or a pull request so we can discuss it!
```
 
简单来说,这个Dockerfile使用了安全参数去执行apt-get install -y openjdk-8-jdk去下载安装Java,而ENV指令配置系统的环境变量。

最后,清单6是Tomcat的[Dockerfile。

代码清单 6. Tomcat Dockerfile

```sh
FROM java:7-jre
ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH
RUN mkdir -p "$CATALINA_HOME"
WORKDIR $CATALINA_HOME
# see

RUN gpg --keyserver pool.sks-keyservers.net --recv-keys \
 05AB33110949707C93A279E3D3EFE6B686867BA6 \
 07E48665A34DCAFAE522E5E6266191C37C037D42 \
 47309207D818FFD8DCD3F83F1931D684307A10A5 \
 541FBE7D8F78B25E055DDEE13C370389288584E7 \
 61B832AC2F1C5A90F0F9B00A1C506407564C17A3 \
 79F7026C690BAA50B92CD8B66A3AD3F4F22C4FED \
 9BA44C2621385CB966EBA586F72C284D731FABEE \
 A27677289986DB50844682F8ACB77FC2E86E29AC \
 A9C5DF4D22E99998D9875A5110C01C5A2F6059E7 \
 DCFD35E0BF8CA7344752DE8B6FB21E8933C60243 \
 F3A04C595DB5B6A5F1ECA43E3B7BBB100D811BBE \
 F7DA48BB64BCB84ECBA7EE6935CD23C10D498E23
ENV TOMCAT_MAJOR 8
ENV TOMCAT_VERSION 8.0.26
ENV TOMCAT_TGZ_URL

RUN set -x \
 && curl -fSL "$TOMCAT_TGZ_URL" -o tomcat.tar.gz \
 && curl -fSL "$TOMCAT_TGZ_URL.asc" -o tomcat.tar.gz.asc \
 && gpg --verify tomcat.tar.gz.asc \
 && tar -xvf tomcat.tar.gz --strip-components=1 \
 && rm bin/*.bat \
 && rm tomcat.tar.gz*
EXPOSE 8080
CMD ["catalina.sh", "run"]
```

严格来说,Tomcat使用了Java 7的父级Dockerfile(默认的最新Java版本是8)。这个Dockerfile设置了CATALINA_HOMEPATH环境变量,然后用mkdir命令新建了CATALINA_HOME目录,WORKDIR指令把当前工作路径更改为CATALINA_HOME,然后RUN指令执行了同一行中一系列的命令:

1. 下载Tomcat压缩包。
2. 下载文件校验码。
3. 验证下载的文件正确。
4. 解压Tomcat压缩包。
5. 删除所有批处理文件(我们是在Linux上运行)。
6. 删除压缩包文件。

把这些命令写在同一行,对应Docker来说就是一条命令,最后Docker会把执行的结果缓存起来,Docker有个策略是检测镜像何时需要重建,以及验证构建过程中的指令是否正确。当一条指令会使镜像更改,Docker会把每个步的结果缓存起来,Docker能把最上一个正确指令产生的镜像启动起来。

EXPOSE指令会让Docker启动一个容器时暴露指定的端口,正如之前我们启动时那样,我们需要告诉Docker哪个物理端口会被映射到容器上(-p参数),EXPOSE的作用就是这个定义Docker容器端口。最后Dockerfile使用catalina.sh脚本启动Tomcat。

如何用Docker重新定义Java虚拟化部署

>>>简单回顾

用Dockerfile从头开始构建Tomcat是一个漫长的过程,我们总结一下目前为止的步骤:

1. 安装Debian Linux。
2. 安装curl和wget。
3. 安装源码管理工具。
4. 下载并安装Java。
5. 下载并安装Tomcat。
6. 暴露Docker实例的8080端口。
7. 用catalina.sh启动Tomcat。

现在你应该成为一个Dockerfile专家了,下一步我们将尝试构建一个自定义Docker镜像。

>>>部署自定义应用到Docker

因为本篇指南主要关注点是如何在Docker中部署Java应用,而不是应用本身,我会构建一个简单的Hello World servlet。你可以从[GitHub]获取到这个项目,源码并无任何特别,只是一个输出"Hello World!"的servlet。更加有趣的是相应的[Dockerfile],如清单7所示。

代码清单 7. Hello World servlet的Dockerfile

```sh
FROM tomcat
ADD deploy /usr/local/tomcat/webapps
```
可能看起来不大一样,但你应该能理解以上代码的作用是:
* FROM tomcat指明这个Dockerfile是基于Tomcat镜像构建。
* ADD deploy 告诉Docker把本地文件系统中的"deploy"目录,复制到Tomcat镜像中的 /usr/local/tomcat/webapps路径 。

在本地使用maven命令编译这个项目:

```sh
mvn clean install
```

这样将会生成一个war包,target/helloworld.war,把这个文件复制到项目的docker/deploy目录(你需要先创建好),最后你要使用上边的Dockerfile构建Docker镜像,在项目的docker目录中执行以下命令:

```sh
docker build -t lygado/docker-tomcat .
```

这个命令让Docker从当前目录(用点号.表示)构建一个新的镜像,并用"-t"打上标签lygado/docker-tomcat,这个例子中,lygado是我的DockerHub用户名,docker-image是镜像名称(你需要替换成你自己的用户名)。查看是否构建成功你可以执行以下命令:

```sh
$ docker images
REPOSITORY                      TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
lygado/docker-tomcat            latest              ccb455fabad9        42 seconds ago      849.5 MB
```

最后,你可以用以下命令加载这个镜像:

```sh
docker run -d -p 8080:8080 lygado/docker-tomcat
```
这个实例启动之后 ,你可以用以下URL访问(请把URL中的IP替换成你虚拟机的IP):

```sh
http://192.168.99.100:8080/helloworld/hello
``` 
还是那样,你可以用容器的ID来终止这个实例。
Docker push

一旦你构建并测试过了你的Docker镜像,你可以把这个镜像推送到你DockerHub的账号中:
```sh
docker push lygado/docker-tomcat
```
这样,你的镜像就能被全世界访问到了,当然,为了隐私起见,你也可以推送到私有的Docker仓库。
下面,我们将把Docker集成到应用的构建过程,目标是在构建应用完成后,会产出一个包含应用的Docker镜像。

>>>把Docker集成到Maven构建过程

在前边的部分,我们创建了一个自定义的Dockerfile,并把WAR包部署到它里边。这样意味着把WAR包从项目的target目录,复制到docker/deploy目录下,并且从命令行中运行docker。这并没花多少功夫,但如果你需要频繁的改动并测试代码,你会发现这个过程很烦琐。而且,如果你需要在一个CI服务器上构建应用,并产出一个Docker镜像,那你需要弄明白怎样把Docker和CI工具整合起来。

现在我们尝试一种更有效的方法,使用Maven和Maven Docker插件来构建一个Docker镜像。

我的用例有这些:
1. 能创建基于Tomcat的Docker镜像,以用于部署我的应用。
2. 能在测试中自行构建。
3. 能整合到前期集成测试和后期集成测试。

docker-maven-plugin能满足这些需求,而且易于使用和理解。

关于 Maven Docker插件

这个插件本身有良好的[文档],这里特别说明一下两个主要的组件:

1. 在POM.xml中配置Docker镜像的构建和运行。
2. 描述哪些文件要包含在镜像中。

清单8是POM.xml中插件的配置,定义了镜像的构建和运行的配置。

代码清单 8. POM 文件的 build 小节, Docker Maven plug-in 配置

```xml

   helloworld
    
      
         org.jolokia
         docker-maven-plugin
         0.13.4
        
            tcp://192.168.99.100:2376                                         /Users/shaines/.docker/machine/machines/default
                true
                  
                    
                       lygado/tomcat-with-my-app:0.1
                       tomcat
                      
                          tomcat
                         
                          dir                          /usr/local/tomcat/webapps                          assembly.xml
                                       

                               

                               
                                       
                                           8080:8080
                                       

                               

                       
                  

               

           

       

 
   
```


正如你所见,这个配置相当简单,包含了以下元素:

Plug-in定义
groupId, artifactIdversion 这些信息指定要用哪个插件。

全局设置
dockerHostcertPath元素,定义了Docker主机的位置,这些配置会用于启动容器,以及指定Docker证书。Docker证书的路径在DOCKER_CERT_PATH环境变量中能看到。

镜像设置
build元素下的所有image元素都定义在images元素下,每个image元素都有镜像相关的配置,与buildrun的配置一样,主要的配置是镜像的名称,在这个例子中,是我的DockerHub用户名(lygado),镜像的名称(tomcat-with-my-app)和镜像的版本号(0.1)。你也可以用Maven的属性来定义这些值。

镜像构建配置
一般构建镜像时,我们会使用docker build命令,以及一个Dockerfile来定义构建过程。Maven Docker插件也允许你使用Dockerfile,但在例子中,我们使用一个运行时生成在内存中的Dockerfile来构建。因此,我们在from元素中定义父级镜像,这个例子中是tomcat,然后在assembly中作其他配置。

使用Maven的maven-assembly-plugin,可以定义一个项目的输出内容,指定包含依赖,模块,文档,或其他文件到一个独立分发的包中。docker-maven-plugin继承了这个标准,在这个例子中,我们选择了dir模式,也就是说定义在src/main/docker/assembly.xml中的文件会被拷贝到Docker镜像中的basedir中。其他模式还有tartgzzipbasedir元素中定义了放置文件的路径,这个例子中是Tomcat的webapps目录。

最后,descriptor元素指定了assembly文件,这个文件位于basedir中定义的src/main/docker中。以上是一个很简单的例子,我建议你通读一下相关文档,特别地,可以了解entrypointcmd元素,这两个元素可以指定启动Docker镜像的命令,env元素可以指定环境变量,runCmds元素类似Dockerfile中的RUN指令,workdir元素可以指定工作路径,volumes元素可以指定要挂载的磁盘卷。简言之,这个插件实现了所有Dockerfile中所需要的语法,所以前面所用到的Dockerfile指令都可以在这个插件中使用。

镜像运行配置
启动Docker镜像时会用到docker run命令,你可以传一些参数给Docker。这个例子中,我们要用docker run -d -p 8080:8080 lygado/tomcat-with-my-app:0.1这个命令启动镜像,所以我们只需要指定一下端口映射。

run元素可以让我们指定所有运行时参数,所以我们指定了把Docker容器中的8080映射到Docker宿主机的8080。另外,还可以在run这节中指定要挂载的卷(使用volumes),或者要链接起来的容器(使用links)。docker:start在集成测试中很常用,在run小节中,我们可以使用wait参数来指定一个时间周期,这样就可以等待到某个日志输出,或者一个URL可用时,才继续执行下去,这样就可以保证在集成测试开始前镜像已经运行起来了。

加载依赖

src/main/docker/assembly.xml文件定义了哪些文件需要复制到Docker镜像中,如清单9所示:
清单 9. assembly.xml

```xml
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
 
   
     
        com.geekcap.vmturbo:hello-world-servlet-example
     

      .
      helloworld.war
   

 


```
在清单 9 中,我们可以看到包含hello-world-servlet-example在内的一个依赖集合,以及复制的目标路径,outputDirectory这个路径是相对于前面提到的basedir的,也就是Tomcat的webapps目录。

这个插件有以下几个Maven targets:
1. docker:build:  构建镜像
2. docker:start: 启动镜像
3. docker:stop: 停止镜像
4. docker:push: 把镜像推送到镜像仓库,如DockerHub
5. docker:remove: 本地删除镜像
6. docker:logs: 输出容器日志

构建镜像
你可以从[GitHub]中获取源码,然后用下边的命令构建:
```sh
mvn clean install
```
用以下命令构建Docker镜像:
```sh
mvn clean package docker:build
```
一旦镜像构建成功,你可以在docker images的返回结果中看到:
```sh
$ docker images
REPOSITORY                  TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
lygado/tomcat-with-my-app   0.1                 1d49e6924d19        16 minutes ago      347.7 MB   
```
可以用以下命令启动镜像:

```sh
mvn docker:start
```
现在可以在docker ps中看到已经启动了,然后可以通过以下URL访问:
```sh
http://192.168.99.100:8080/helloworld/hello
```
最后,可以用以下命令停止容器:
```sh
mvn docker:stop
```

Docker是一种使进程虚拟化的容器技术,它提供了一系列Docker客户端命令来调用Docker守护进程。在Linux上,Docker守护进程可以直接运行于Linux操作系统,但是在Windows和Mac上,需要有一个Linux虚拟机来运行Docker守护进程。Docker镜像包含了一个轻量级的操作系统,还额外包含了应用运行的依赖库。Docker镜像由Dockerfile定义,可以在Dockerfile中包含一系列配置镜像的指令。

看完上述内容,你们掌握如何用Docker重新定义Java虚拟化部署的方法了吗?如果还想学到更多技能或想了解更多相关内容,欢迎关注创新互联行业资讯频道,感谢各位的阅读!


网站名称:如何用Docker重新定义Java虚拟化部署
转载注明:http://pwwzsj.com/article/ghsdhd.html