关于使用ansible-playbook部署java业务代码

01. 背景

一般地,在公司的生产环境中,由于需求变更和代码更新频繁的问题,那么应对措施就是工具化平台化使用到该生产环境中。ansible-playbook可以简单便捷地管理配置服务。

02. 需求

对于代码部分,一般是git或svn作为代码管理仓库。语言使用java,那么打包则由maven来打包,使用maven私服来管理包。即是先在git下载代码,然后使用mvn来打包,经过传输到生产服务器,然后启动服务,最终检查服务是否成功。

03. ansible-playbook内容

---
- name: Local ops
  hosts: 127.0.0.1
  remote_user: mai
  become: yes
  become_user: root
  gather_facts: False
  vars:
  - super_user: mai
  - git_user: autouser
  - git_passwd: 123456
  - project_name: testauto
  - project_gitlocal_dir: /tmp/logstest/{{ project_name }}
  tasks:
  - name: Delete {{ project_name }} code.
    file: 
      path: '{{ project_gitlocal_dir }}'
      state: absent

  - name: Downloading git code.
    git:
      repo: https://{{ git_user | urlencode }}:{{ git_passwd | urlencode}}@git.mairoot.com/test/{{ project_name }}.git
      version: develop
      dest: '{{ project_gitlocal_dir }}'
      force: yes

  - name: Mvn make pack.
    shell: cd {{ project_gitlocal_dir }}; /data/apps/apache-maven-3.5.4-java8/bin/mvn clean package -Pdev


- name: Remote ops
  hosts: testhost
  remote_user: mai
  become: yes
  become_user: root
  gather_facts: False
  vars:
  - project_name: testauto
  - project_api_name: testautoapi
  - project_gitlocal_dir: /tmp/logstest/{{ project_name }}
  - project_api_dir_name: /data/apps/backend/{{ project_api_name }}
  - run_user: testauto
  - run_group: suwe
  tasks:
  - name: Mkdir {{ project_name }}
    file:
      path: '{{ project_api_dir_name }}'
      state: directory
      owner: '{{ run_user }}'
      group: '{{ run_group }}'
      mode: 0755

  - name: Copy file to remote install.
    copy:
      src: "{{ item.src }}"
      dest: "{{ item.dest }}"
    with_items:
    - { src: '{{ project_gitlocal_dir }}/testauto-api/target/lib', dest: '{{ project_api_dir_name }}' }
    - { src: '{{ project_gitlocal_dir }}/testauto-api/target/testauto.jar', dest: '{{ project_api_dir_name }}' }

  - name: Isn't docker-java or not.
    shell: docker ps -a| grep {{ project_api_name }}
    register: docker_{{ project_api_name }}_value
    ignore_errors: True

  - name: Create and Start docker-java server
    when: docker_{{ project_api_name }}_value | failed
    shell: docker run -itd -p 8089:8080 --name {{ project_api_name }} -v {{ project_api_dir_name }}:/app -v {{ project_api_dir_name }}/logs:/logs java:8 /bin/bash -c 'java -jar -Dspring.profiles.active=prod -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParNewGC -XX:NewSize=16G -XX:MaxPermSize=16G -Xms16G -Xmx16G -server -Duser.timezone=Asia/Shanghai -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8080 -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=1099 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=172.17.0.1 /app/testauto.jar'

  - name: Start docker-java server
    when: docker_{{ project_api_name }}_value | succeeded
    shell: docker restart {{ project_api_name }}


- name: Local ops
  hosts: 127.0.0.1
  remote_user: mai
  become: yes
  become_user: root
  gather_facts: False
  vars:
  - project_name: testauto
  - project_gitlocal_dir: /tmp/logstest/{{ project_name }}
  tasks:
  - name: Delete testauto code.
    file: 
      path: '{{ project_gitlocal_dir }}'
      state: absent

04. 简单解释

简单解析上面内容,主要应用到的是可以把git密码保存到文件中,一个ansible-playbook里有多个play,一个play里可以多个tasks。

Java Tomcat Demo配置

简单写了个 Java MVC + Tomcat Demo 和 SpringBoot Demo 配置,小demo仅仅是用来测试的,各家还得根据自己公司的调调来配置。

未分类

高级任务-Deploy前置任务

在宿主机未检出代码前的前置任务,常为安装依赖、配置环境变量等

高级任务-Deploy后置任务

# 打包编译
${MVN_HOME}/bin/mvn clean package -Dmaven.test.skip=true
cp target/walle-web.war .

高级任务-Release前置任务

# 停服
${TOMCAT_HOME}/bin/shutdown.sh

高级任务-Release后置任务

# tomcat 更新服务
cp ${WEBROOT}/walle-web.war ${TOMCAT_HOME}/webapps/
# 服务启动
${TOMCAT_HOME}/bin/startup.sh

未分类

SpringBoot的部署的方式有多种,有java -jar xx.jar,也有配置Tomcat部署方式,结合热部署、配置中心,以及ansible等方案。

使用jenkins+svn自动部署java/vue项目

之前发布代码需要每次本地打包–>发到服务器–>重启tomcat等一系列操作,服务器多了会很繁琐,使用jenkins可以自动部署和统一管理,解放人力,挤出很多喝茶时间。

1、下载jenkins.war
官网地址 http://jenkins-ci.org/
下载最新版本
http://mirrors.jenkins-ci.org…

2、把下载的war包放到到服务器tomcat的webapps目录下,启动tomcat
3、启动成功后log会打印一个UUID密码,复制,登陆时用
4、输入tomact地址,进入jenkins首页,会提示自动安装需要的插件(如果不能在线安装,需要去自己下载之后上传
插件下载地址 http://updates.jenkins-ci.org…

5、创建项目
  
首页点击新建item

未分类

创建一个自由风格项目,自定义一个名称projectName,确认

未分类

6、配置svn,点击add 添加自己的svn账户

未分类

7、配置触发器(指定时间自动部署)

不需要自动触发的同学可略过此步骤,之后手动点击立即构建按钮即可
05 10 * * * 为cron表达式,表示每天上午10:05

未分类

8、设置execute shell(部署时执行的脚本)

这里用java项目举例

BUILD_ID=DONTKILLME
# ProjectName是刚才**第5步**中填入的名称,jenkins默认工作空间为/root/.jenkins/workspace
cd /root/.jenkins/workspace/projectName/
# 将代码打包
mvn package
# 将打包后的代码移到服务器的tomcat目录下,这里我自己写了一个deploy.sh去处理copy-解压-备份-重启tomcat等一系列操作
cd /root/.jenkins/workspace/projectName/target
mv projectName.war /home/shibo && deploy.sh

以上shell脚本只是举例,具体可根据自己需求更改,比如vue的话就将mvn package改为npm run build……

到这就可以保存了,然后测试一下是否可以正常使用。首页点击制定项目下三角,点击立即构建即可。

未分类

下面是我在搭建的时候遇到的一些问题,仅供参考:
1、第一次登录后下线,第二次不能用user账户登陆
解决方法:去/root/.jenkins/secrets下找到initialAdminPassword ,复制密码,用admin登陆
2、maven分布式子项目没有web.xml,导致mvn打包报错
解决方法:在pom.xml中添加

<properties>
    <failOnMissingWebXml>false</failOnMissingWebXml>
</properties>

3、execute shell中执行deploy.sh脚本时,有用到shutdown.sh和startup.sh两个命令,
发现tomcat关闭后,startup不能自动启动
原因是execute会自动kill掉tomcat
解决方法:在execute shell第一行添加BUILD_ID=DONTKILLME
4、execute shell时,有时有一些不是很重要的脚本命令出错,我们需要忽略他们,继续执行,
需要点开 高级–>设置Exit code to set build unstable = 1

使用Jenkins自动化部署Java项目

Jenkins介绍

Jenkins是领先的开源自动化服务器,他提供了数百个插件来支持任何项目的构建、部署和自动化。

Jenkins下载

Jenkins的官方网站|下载地址

wget http://mirrors.jenkins.io/war-stable/latest/jenkins.war

Jenkins安装

  1. 启动Jenkins :java -jar jenkins.war
  2. 在浏览器中输入 localhost:8080
  3. 根据提示输入Jenkins的默认密码
  4. 安装建议的插件
  5. 创建admin用户
  6. 选择start using jenkins

Jenkins插件安装

rebuilder : 重新构建
safe restart: 安全重启

Jenkins基础配置

  • 配置全局安全属性
    在Configure Global Security中使用安装矩阵添加admin用户和test用户的权限

  • 添加自定义用户test01,并赋予test的用户权限

自动化部署项目

部署过程

  1. git同步最新代码
  2. 使用maven打包项目
  3. 停止tomcat服务器
  4. 部署项目
  5. 启动tomcat服务器

部署脚本

#!/usr/bin/env bash
#编译+部署order站点

#需要配置如下参数
# 项目路径, 在Execute Shell中配置项目路径, pwd 就可以获得该项目路径
# export PROJ_PATH=这个jenkins任务在部署机器上的路径

# 输入你的环境上tomcat的全路径
# export TOMCAT_APP_PATH=tomcat在部署机器上的路径

### base 函数
killTomcat()
{
    pid=`ps -ef|grep tomcat|grep java|awk '{print $2}'`
    echo "tomcat Id list :$pid"
    if [ "$pid" = "" ]
    then
      echo "no tomcat pid alive"
    else
      kill -9 $pid
    fi
}
cd $PROJ_PATH/order
mvn clean install

# 停tomcat
killTomcat

# 删除原有工程
rm -rf $TOMCAT_APP_PATH/webapps/ROOT
rm -f $TOMCAT_APP_PATH/webapps/ROOT.war
rm -f $TOMCAT_APP_PATH/webapps/order.war

# 复制新的工程
cp $PROJ_PATH/order/target/order.war $TOMCAT_APP_PATH/webapps/

cd $TOMCAT_APP_PATH/webapps/
mv order.war ROOT.war

# 启动Tomcat
cd $TOMCAT_APP_PATH/
sh bin/startup.sh

Jenkins部署任务

1.创建Jenkins任务

  • 输入Jenkins的任务名称
  • 选择构建一个自由风格的软件项目
  • 填写任务描述

2.填写Server信息
3. 配置git参数

  • 输入git地址
  • 在Additional Behaviours中选择Check out to a sub-directory并设置文件名为order

4.填写构建语句,部署环境

  • 在构建中添加构建步骤Execute shell
# 在Jenkins任务执行完毕之后只关闭Jenkins进程,不关闭Server进程,如果不设置Server也会被关闭
BUILD_ID=DONTKILLME
# 加载配置文件
. /etc/profile
# 配置运行参数
export RROJ_PATH=`pwd`
export TOMCAT_PATH=/root/apache-tomcat-9.0.8
# 运行部署脚本
sh $RROJ_PATH/order/deploy.sh
  • 点击立即构建

5.验证部署结果

使用浏览器访问192.168.100.133:8080验证项目是否部署成功

在Ubuntu 18.04上使用apt安装Java

安装默认的JRE/JDK

安装Java的最简单方法是使用与Ubuntu一起打包的版本。默认情况下,Ubuntu 18.04包含Open JDK,它是JRE和JDK的开源版本。

该软件包将安装OpenJDK 10或11。

  • 在现在,这将安装OpenJDK 10。
  • 在2018年9月以后,这将安装OpenJDK 11。

要安装此版本,请先更新软件包索引:

sudo apt update

接下来,检查 Java 是否已经安装:

java -version

如果Java当前未安装,你将看到以下输出:

Command 'java' not found, but can be installed with:

apt install default-jre
apt install openjdk-11-jre-headless
apt install openjdk-8-jre-headless
apt install openjdk-9-jre-headless

执行以下命令来安装OpenJDK:

sudo apt install default-jre

该命令将安装Java运行时环境(JRE)。这将允许你运行几乎所有的Java软件。

验证安装:

java -version

你将看到以下输出:

openjdk version "10.0.1" 2018-04-17
OpenJDK Runtime Environment (build 10.0.1+10-Ubuntu-3ubuntu1)
OpenJDK 64-Bit Server VM (build 10.0.1+10-Ubuntu-3ubuntu1, mixed mode)

除了JRE之外,你可能还需要Java开发工具包(JDK)才能编译和运行一些特定的基于Java的软件。要安装JDK,请执行以下命令,该命令也将安装JRE:

sudo apt install default-jdk

通过检查javac Java编译器的版本来验证是否安装了JDK :

javac -version

你将看到以下输出:

javac 10.0.1

接下来,我们来看看指定我们要安装的OpenJDK版本。

安装OpenJDK的特定版本

虽然你可以安装默认的OpenJDK软件包,但你也可以安装不同版本的
OpenJDK。

OpenJDK 8

Java 8是目前的长期支持版本,虽然公共维护在2019年1月结束,但仍然得到广泛支持。要安装OpenJDK 8,请执行以下命令:

sudo apt install openjdk-8-jdk

验证安装:

java -version

你会看到这样的输出:

openjdk version "1.8.0_162"
OpenJDK Runtime Environment (build 1.8.0_162-8u162-b12-1-b12)
OpenJDK 64-Bit Server VM (build 25.162-b12, mixed mode)

也可以只安装JRE,你可以通过执行sudo apt install openjdk-8-jre来安装它。

OpenJDK 10/11

Ubuntu的存储库包含一个安装Java 10或11的软件包。在2018年9月之前,该软件包将安装OpenJDK 10.一旦Java 11发布,该软件包将安装Java 11。

要安装OpenJDK 11,请执行以下命令:

sudo apt install openjdk-11-jdk

要仅安装JRE,请使用以下命令:

sudo apt install openjdk-11-jre

安装Oracle JDK

如果你想安装由Oracle发布的正式版本Oracle JDK,则需要为要使用的版本添加新的软件包存储库。

要安装作为最新LTS版本的Java 8,请首先添加其软件包存储库:

sudo add-apt-repository ppa:webupd8team/java

当你添加存储库时,你会看到如下消息:

 Oracle Java (JDK) Installer (automatically downloads and installs Oracle JDK8). There are no actual Jav
a files in this PPA.

Important -> Why Oracle Java 7 And 6 Installers No Longer Work: http://www.webupd8.org/2017/06/why-oracl
e-java-7-and-6-installers-no.html

Update: Oracle Java 9 has reached end of life: http://www.oracle.com/technetwork/java/javase/downloads/j
dk9-downloads-3848520.html

The PPA supports Ubuntu 18.04, 17.10, 16.04, 14.04 and 12.04.

More info (and Ubuntu installation instructions):
- for Oracle Java 8: http://www.webupd8.org/2012/09/install-oracle-java-8-in-ubuntu-via-ppa.html

Debian installation instructions:
- Oracle Java 8: http://www.webupd8.org/2014/03/how-to-install-oracle-java-8-in-debian.html

For Oracle Java 10, see a different PPA: https://www.linuxuprising.com/2018/04/install-oracle-java-10-in-ubuntu-or.html

More info: https://launchpad.net/~webupd8team/+archive/ubuntu/java
Press [ENTER] to continue or Ctrl-c to cancel adding it.

按ENTER继续。然后更新你的软件包列表

sudo apt update

包列表更新后,安装Oracle Java 8:

sudo apt install oracle-java8-installer

你的系统将从Oracle下载JDK并要求你接受许可协议。接受协议并安装JDK。

管理Java版本

你可以在一台服务器上安装多个Java。你可以使用update-alternatives命令配置哪个版本是命令行上使用的默认版本。

sudo update-alternatives --config java

如果你已经在本教程中安装了所有版本的Java,则输出结果如下所示:

There are 3 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
* 0            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1101      auto mode
  1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1101      manual mode
  2            /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java   1081      manual mode
  3            /usr/lib/jvm/java-8-oracle/jre/bin/java          1081      manual mode

选择与 Java 版本关联的数字以将其用作默认值,或按下ENTER以保留当前设置。

你可以为其他Java命令执行此操作,如compiler(javac):

sudo update-alternatives --config javac

可以运行该命令的其他命令包括但不限于:keytool,javadoc和jarsigner。

设置JAVA_HOME环境变量
许多使用Java编写的程序使用JAVA_HOME环境变量来确定Java的安装位置。

要设置此环境变量,请先确定Java的安装位置。使用update-alternatives命令:

sudo update-alternatives --config java

该命令显示Java的每个安装版本及其安装路径:

There are 3 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
* 0            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1101      auto mode
  1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1101      manual mode
  2            /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java   1081      manual mode
  3            /usr/lib/jvm/java-8-oracle/jre/bin/java          1081      manual mode

Press <enter> to keep the current choice[*], or type selection number:

在这种情况下,安装路径如下所示:

OpenJDK 11位于 /usr/lib/jvm/java-11-openjdk-amd64/bin/java.
OpenJDK 8位于/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java。
Oracle Java 8位于/usr/lib/jvm/java-8-oracle/jre/bin/java。

复制首选安装的路径。然后打开/etc/environment使用nano或你最喜爱的文本编辑器:

sudo nano /etc/environment

在该文件的末尾,添加以下行,确保使用自己的复制路径替换突出显示的路径:

JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64/bin/java"

修改此文件将为JAVA_HOME系统上的所有用户设置路径。

保存文件并退出编辑器。

现在重新加载此文件以将更改应用于当前会话:

source /etc/environment

验证是否设置了环境变量:

echo $JAVA_HOME

你会看到你刚刚设置的路径:

/usr/lib/jvm/java-11-openjdk-amd64/bin/java

其他用户需要执行该命令source /etc/environment或注销并重新登录才能应用此设置。

Kubernetes之路 1 – Java应用资源限制的迷思

未分类

随着容器技术的成熟,越来越多的企业客户在企业中选择Docker和Kubernetes作为应用平台的基础。然而在实践过程中,还会遇到很多具体问题。本系列文章会记录阿里云容器服务团队在支持客户中的一些心得体会和最佳实践。我们也欢迎您通过邮件和钉钉群和我们联系,分享您的思路和遇到的问题。

在对Java应用容器化部署的过程中,有些同学反映:自己设置了容器的资源限制,但是Java应用容器在运行中还是会莫名奇妙地被OOM Killer干掉。

这背后一个非常常见的原因是:没有正确设置容器的资源限制以及对应的JVM的堆空间大小。

我们拿一个tomcat应用为例,其实例代码和Kubernetes部署文件可以从Github中获得。

git clone https://github.com/denverdino/system-info
cd system-info`

下面是一个Kubernetes的Pod的定义描述:

  • Pod中的app是一个初始化容器,负责把一个JSP应用拷贝到 tomcat 容器的 “webapps”目录下。注: 镜像中JSP应用index.jsp用于显示JVM和系统资源信息。
  • tomcat 容器会保持运行,而且我们限制了容器最大的内存用量为256MB内存。
apiVersion: v1
kind: Pod
metadata:
  name: test
spec:
  initContainers:
  - image: registry.cn-hangzhou.aliyuncs.com/denverdino/system-info
    name: app
    imagePullPolicy: IfNotPresent
    command:
      - "cp"
      - "-r"
      - "/system-info"
      - "/app"
    volumeMounts:
    - mountPath: /app
      name: app-volume
  containers:
  - image: tomcat:9-jre8
    name: tomcat
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - mountPath: /usr/local/tomcat/webapps
      name: app-volume
    ports:
    - containerPort: 8080
    resources:
      requests:
        memory: "256Mi"
        cpu: "500m"
      limits:
        memory: "256Mi"
        cpu: "500m"
  volumes:
  - name: app-volume
    emptyDir: {}

我们执行如下命令来部署、测试应用

$ kubectl create -f test.yaml
pod "test" created
$ kubectl get pods test
NAME      READY     STATUS    RESTARTS   AGE
test      1/1       Running   0          28s
$ kubectl exec test curl http://localhost:8080/system-info/
...

我们可以看到HTML格式的系统CPU/Memory等信息,我们也可以用 html2text 命令将其转化成为文本格式。

注意:本文是在一个 2C 4G的节点上进行的测试,在不同环境中测试输出的结果会有所不同

$ kubectl exec test curl http://localhost:8080/system-info/ | html2text

Java version     Oracle Corporation 1.8.0_162
Operating system Linux 4.9.64
Server           Apache Tomcat/9.0.6
Memory           Used 29 of 57 MB, Max 878 MB
Physica Memory   3951 MB
CPU Cores        2
                                          **** Memory MXBean ****
Heap Memory Usage     init = 65011712(63488K) used = 19873704(19407K) committed
                      = 65536000(64000K) max = 921174016(899584K)
Non-Heap Memory Usage init = 2555904(2496K) used = 32944912(32172K) committed =
                      33882112(33088K) max = -1(-1K)

我们可以发现,容器中看到的系统内存是 3951MB,而JVM Heap Size最大是 878MB。纳尼?!我们不是设置容器资源的容量为256MB了吗?如果这样,当应用内存的用量超出了256MB,JVM还没对其进行GC,而JVM进程就会被系统直接OOM干掉了。

问题的根源在于:

  • 对于JVM而言,如果没有设置Heap Size,就会按照宿主机环境的内存大小缺省设置自己的最大堆大小。
  • Docker容器利用CGroup对进程使用的资源进行限制,而在容器中的JVM依然会利用宿主机环境的内存大小和CPU核数进行缺省设置,这导致了JVM Heap的错误计算。

类似,JVM缺省的GC、JIT编译线程数量取决于宿主机CPU核数。如果我们在一个节点上运行多个Java应用,即使我们设置了CPU的限制,应用之间依然有可能因为GC线程抢占切换,导致应用性能收到影响。

了解了问题的根源,我们就可以非常简单地解决问题了

解决思路

开启CGroup资源感知

Java社区也关注到这个问题,并在JavaSE8u131+和JDK9 支持了对容器资源限制的自动感知能力 https://blogs.oracle.com/java-platform-group/java-se-support-for-docker-cpu-and-memory-limits

其用法就是添加如下参数

java -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap …

我们在上文示例的tomcat容器添加环境变量 “JAVA_OPTS”参数

apiVersion: v1
kind: Pod
metadata:
  name: cgrouptest
spec:
  initContainers:
  - image: registry.cn-hangzhou.aliyuncs.com/denverdino/system-info
    name: app
    imagePullPolicy: IfNotPresent
    command:
      - "cp"
      - "-r"
      - "/system-info"
      - "/app"
    volumeMounts:
    - mountPath: /app
      name: app-volume
  containers:
  - image: tomcat:9-jre8
    name: tomcat
    imagePullPolicy: IfNotPresent
    env:
    - name: JAVA_OPTS
      value: "-XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"
    volumeMounts:
    - mountPath: /usr/local/tomcat/webapps
      name: app-volume
    ports:
    - containerPort: 8080
    resources:
      requests:
        memory: "256Mi"
        cpu: "500m"
      limits:
        memory: "256Mi"
        cpu: "500m"
  volumes:
  - name: app-volume
    emptyDir: {}

我们部署一个新的Pod,并重复相应的测试

$ kubectl create -f cgroup_test.yaml
pod "cgrouptest" created

$ kubectl exec cgrouptest curl http://localhost:8080/system-info/ | html2txt
Java version     Oracle Corporation 1.8.0_162
Operating system Linux 4.9.64
Server           Apache Tomcat/9.0.6
Memory           Used 23 of 44 MB, Max 112 MB
Physica Memory   3951 MB
CPU Cores        2
                                          **** Memory MXBean ****
Heap Memory Usage     init = 8388608(8192K) used = 25280928(24688K) committed =
                      46661632(45568K) max = 117440512(114688K)
Non-Heap Memory Usage init = 2555904(2496K) used = 31970840(31221K) committed =
                      32768000(32000K) max = -1(-1K)

我们看到JVM最大的Heap大小变成了112MB,这很不错,这样就能保证我们的应用不会轻易被OOM了。随后问题又来了,为什么我们设置了容器最大内存限制是256MB,而JVM只给Heap设置了112MB的最大值呢?

这就涉及到JVM的内存管理的细节了,JVM中的内存消耗包含Heap和Non-Heap两类;类似Class的元信息,JIT编译过的代码,线程堆栈(thread stack),GC需要的内存空间等都属于Non-Heap内存,所以JVM还会根据CGroup的资源限制预留出部分内存给Non Heap,来保障系统的稳定。(在上面的示例中我们可以看到,tomcat启动后Non Heap占用了近32MB的内存)

在最新的JDK 10中,又对JVM在容器中运行做了进一步的优化和增强。

容器内部感知CGroup资源限制

如果无法利用JDK 8/9的新特性,比如还在使用JDK6的老应用,我们还可以在容器内部利用脚本来获取容器的CGroup资源限制,并通过设置JVM的Heap大小。

Docker1.7开始将容器cgroup信息挂载到容器中,所以应用可以从 /sys/fs/cgroup/memory/memory.limit_in_bytes 等文件获取内存、 CPU等设置,在容器的应用启动命令中根据Cgroup配置正确的资源设置 -Xmx, -XX:ParallelGCThreads等参数

在 https://yq.aliyun.com/articles/18037 一文中已经有相应的示例和代码,本文不再赘述

总结

本文分析了Java应用在容器使用中一个常见Heap设置的问题。容器与虚拟机不同,其资源限制通过CGroup来实现。而容器内部进程如果不感知CGroup的限制,就进行内存、CPU分配可能导致资源冲突和问题。

我们可以非常简单地利用JVM的新特性和自定义脚本来正确设置资源限制。这个可以解决绝大多数资源限制的问题。

关于容器应用中资源限制还有一类问题是,一些比较老的监控工具或者free/top等系统命令,在容器中运行时依然会获取到宿主机的CPU和内存,这导致了一些监控工具在容器中运行时无法正常计算资源消耗。社区中常见的做法是利用 lxcfs 来让容器在资源可见性的行为和虚机保持一致,后续文章会介绍其在Kubernetes上的使用方案。

阿里云Kubernetes服务 全球首批通过Kubernetes一致性认证,简化了Kubernetes集群生命周期管理,内置了与阿里云产品集成,也将进一步简化Kubernetes的开发者体验,帮助用户关注云端应用价值创新。

Ubuntu 安装java8(jdk8)和java7(jdk7)并灵活切换

前言

本机装的是 jdk7 ,无奈最近看的源码不少都已经拥抱 jdk8 了。便于调试,安装了新的 java 版本。

安装 jdk

这里简单说明下 Ubuntu 下 jdk8 的安装过程,jdk7 的类似,不再赘述。

下载安装包: http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html ,选择 jdk-8u162-linux-x64.tar.gz。

新建目录并解压到该目录

sudo mkdir /usr/lib/java
sudo tar zxvf ./jdk-8u162-linux-x64.tar.gz -C /usr/lib/java
sudo mv /usr/lib/java/jdk1.8.0_162/ /usr/lib/java/jdk8

打开配置文件, sudo gedit /etc/profile, 在文件中加入以下内容

export JAVA_HOME=/usr/lib/java/jdk8
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

将新安装的 jdk 加入到选项里

sudo update-alternatives --install /usr/bin/java java /usr/lib/java/jdk8/bin/java 300
sudo update-alternatives --install /usr/bin/javac javac /usr/lib/java/jdk8/bin/javac 300

通过 sudo update-alternatives –config java 指令,选择相应的jdk即可!

$ sudo update-alternatives --config java       
There are 3 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
  0            /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java   1071      auto mode
* 1            /usr/lib/java/jdk7/bin/java                      300       manual mode
  2            /usr/lib/java/jdk8/bin/java                      300       manual mode
  3            /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java   1071      manual mode

Press enter to keep the current choice[*], or type selection number: 2
update-alternatives: using /usr/lib/java/jdk8/bin/java to provide /usr/bin/java (java) in manual mode

然后在命令行里查看 jdk 的版本

$ java -version
java version "1.8.0_162"
Java(TM) SE Runtime Environment (build 1.8.0_162-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.162-b12, mixed mode)

切换 jdk 版本

修改 $PATH 中的java路径,然后通过 sudo update-alternatives –config java 指令切换版本即可!

Linux使用crontab运行Java程序定时任务小记

Linux中,crontab的功能是十分强大的,能够方便的调度程序的运行,甚至在很多时候能够替代程序中的定时任务。

它的命令格式和主要参数如下:

命令格式
crontab [-u user] [ -e | -l | -r ]

命令参数
-u user:用来设定某个用户的crontab服务;
file:file是命令文件的名字,表示将file做为crontab的任务列表文件并载入crontab。如果在命令行中没有指定这个文件,>crontab命令将接受标准输入(键盘)上键入的命令,并将它们载入crontab。
-e:编辑某个用户的crontab文件内容。如果不指定用户,则表示编辑当前用户的crontab文件。
-l:显示某个用户的crontab文件内容,如果不指定用户,则表示显示当前用户的crontab文件内容。
-r:从/var/spool/cron目录中删除某个用户的crontab文件,如果不指定用户,则默认删除当前用户的crontab文件。
-i:在删除用户的crontab文件时给确认提示。

图片化格式说明:

未分类

本次因为需要推送一批数据,简单起见用Java写了个jar程序,用命令行java -jar push.jar调用完事,但是数据是每天都要推送的,难道每天都要手工去执行一下命令行?这显然不切实际。

为了这么个小程序开发个定时任务也嫌麻烦,后来就想到了Linux系统的crontab,但是在使用过程中还是碰到了几个问题,在此记录一下。

第一步,编写start_pust.sh文件,内容简单如下:

#!/bin/bash
java -jar /home/liyd/push.jar

为了避免路径问题引起的错误,这里使用了绝对路径来保证执行正确。

第二步,编写crontab.txt文件,简单的一行指定执行时间:

34 1 * * * /home/liyd/start_push.sh

每天的1点34分调用push.jar。

最后指定crontab运行:

crontab crontab.txt

到这里设置就都完成了,按照我们的预想每天的1点34分就会执行pust.jar推送数据。

可是事情往往不会按我们预想的发展,我们发现程序根本就没有执行,这是为什么呢?因为在这之前我用命令行直接./start_push.sh都是可以的呀。

只能查查资料了,发现网上也有很多人碰到这个问题,总结起来两点:

一、路径问题

二、环境变量问题

这里我为了避免出错已经使用了绝对路径,那看来就是环境变量的问题了。

原来crontab并不会加载环境变量配置,需要我们在脚本中设置,Java程序没有JDK等环境变量当前不能运行了。

修改前面的start_push.sh脚本,加入profile文件的读取:

#!/bin/bash
. /etc/profile
. ~/.bash_profile
java -jar /home/liyd/push.jar

到这里,程序能够正常运行了,使用ps aux | grep java能够看到执行的进程,但是我的Java程序死活没有日志输出啊,查看我的日志配置:

  <appender name="DEFAULT-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">
  <param name="file" value="${user.dir}/logs/common-default.log"/>
  <param name="append" value="true"/>
  <param name="encoding" value="UTF-8"/>
  <layout class="org.apache.log4j.PatternLayout">
  <param name="ConversionPattern" value="[%x][%r][%p][%t] %d{HH:mm:ss,SSS} method:%l %m%n"/>
  </layout>
  </appender>

本来应该是输出到当前项目的logs文件夹下的,这里初步估计应该是${user.dir}这个变量又找不到了吧。

再次修改start_pust.sh文件,加入user.dir参数:

#!/bin/bash
. /etc/profile
. ~/.bash_profile
java -Duser.dir="/home/liyd/" -jar /home/liyd/push.jar

到这里,终于一切正常!

Centos 7 Java配置maven+jenkins+git(svn)+tomcat自动编译和部署(持续集成)

目的

在开发中,需要经常频繁的对测试服务器进行部署,而且在多人协同中开发经常遇到的问题就是别人更新了他的代码,而你去更新你的代码时并没有更新到别人的代码,导致测试环境的代码不是最新,当然这个问题也好解决,那就是每次更新的时候先获取版本控制器上面的代码,然后更新,当然每次这样操作都是耗时耗力的,如果是整个项目更新,一般项目至少3、40M上传到服务器也需要一定的时间,而部分更新,也需要找到指定的文件或者整个代码覆盖,然后重启服务器(Tomcat里面直接覆盖class虽然可以配置热加载,但是容易内存溢出),就我工作中的情况而言,是每次都需要先把代码上传到服务器-解压-找到Tomcat进程id(Linux)-kill线程-启动Tomcat,每次下来就需要最少几分钟时间,而且每天有可能多次部署,所以对整个工作效率是有一定影响的。正是因为以上种种,所以才有了本文,而本文最终的结果就是一旦代码上传到Git或者svn的时候,代码能自动部署到服务器上面去,这样我们就只需要吧正确的代码提交的版本控制器,就不用理会服务器的更新了。

jenkins部署

  • Jenkins是一个开源软件项目,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能。

  • Jenkins是基于Java开发的一种持续集成工具,用于监控持续重复的工作,功能包括:

    • 持续的软件版本发布/测试项目。

    • 监控外部调用执行的工作。

  • Jenkins能做的东西有很多,不过本文只介绍一个简单的自动编译打包部署,首先下载Jenkins,推荐下载war包, 下载地址: https://jenkins.io/download/

基础准备

配置jdk+tomcat: http://www.okay686.cn/628.html

关闭selinux 以及 firewall 服务。

本文是基于Centos 7,war环境部署的,把下载好的war文件直接放到Tomcat中,然后启动Tomcat,启动成功后访问tomcat的jenkins项目如:

war包下载: http://mirrors.jenkins.io/war-stable/latest/jenkins.war

http://192.168.96.129:8080/jenkins 会看到以下界面:

未分类

注意红色框中的红色文字,那个是初始密码的路径,直接根据路径找到initialAdminPassword文件并打开,把密码复制出来,输入到页面中点击continue按钮,进入下一步: ( /root/.jenkins/secrets/initialAdminPassword )

未分类

Jenkins拥有很多插件,一般在开始我们并不清楚需要什么插件的时候,可以选择自定义安装,把所有基本的插件全部安装好,此页面第一个按钮是安装推荐插件,第二个是自己选择安装,这里我选择第二个按钮。

未分类

此界面是初始化安装插件的界面,先选择All插件,然后点击install

未分类

在这个界面需要多等一下,因为是在网上下载插件,而且是外国的网站,所以经常有下载失败的情况,最好打开V梯P子N,当所有插件安装完成后会有continue按钮出现,如果没有则刷新一下页面,当然也可能存在有插件安装失败,根据自己是否需要自行选择retry或continue,这里因为我的都已经安装完成了,所以进入到了下一个页面.

未分类

在此页面设置用户名和密码,记得点击save and finish按钮,如果选择了Continue as admin,会把用户名重置admin,然后密码也是你设置的密码,而是初始化文件中的密码,设置完成之后的页面.

未分类

点击Start using Jenkins 即可

未分类

Jenkins主界面

未分类

配置Jenkins

创建项目之前先要对Jenkins进行基本的配置,比如jdk的目录,git命令的目录和maven的目录等等

首先点击 系统管理

进入管理页面后如图:

未分类

点击 Global Tool Configuration 进入插件配置页面

配置jdk

(不晓得安装位置,好办,打开 vim /etc/profile 就可以找到!)

未分类

点击新增JDK按钮,会显示jdk配置form,如果电脑上已经安装了jdk则可以去掉自动安装,不过如果是用Tomcat运行的Jenkins那么是肯定已经安装了的,这里我们只需要配置好 jdk别名 和 JAVA_HOME 即可

配置git

未分类

需要将git的正确路径配置到Path to Git executable中。

配置maven

未分类

跟jdk相同,配置好名字和路径即可,当然也可以选择自动安装,不过还是推荐手动安装然后配置,配置好了之后点击save即可

当然还有现在很火的Gradle (有空写个教程,在此,我没有配置)

未分类

安装插件

由于新版默认没有将war部署到Tomcat的插件,所以需要手动安装,在系统管理中选择管理插件,再选择可选插件,搜索 Deploy to Container Plugin ,然后勾选点击直接安装

创建Jenkins任务

点击开始创建一个新任务进入任务创建页面:

未分类

先输入项目名字,然后选择构建一个maven项目,最后点击ok按钮

选择版本控制器

页面中找到源码管理模块,根据项目使用的版本控制器选择,如我们使用的git,则选择git

未分类

选择构建触发器

如果是git的话,可以直接通过GitLab(WebHooks)来实现触发,这样你每次提交到配置编译的分支就会git就会通知,不过目前我知道的是git.oschina.NET的钩子没有作用,当然如果不是git或者钩子没有作用的时候,可以用最简单的,定时查询。

未分类

这样是每10分钟查询一次,如果有更新就构建,具体Poll SCM的参数可以百度,那里更加详细

配置编译命令

编译命令我们可以直接配置最简单的命令编译:

未分类

选择Execute shell,在出来的界面中配置maven命令就行了,比如

mvn install

配置部署到Tomcat

点击新增构建后操作,选择 Deploy war/ear to a container ,然后配置 WAR/EAR files ,这个war的地址,一般都 target/xxx.war ,xxx是war的文件名。

然后点击Add Container,添加Tomcat服务器:

未分类

配置好Tomcat的管理员用户和密码以To及mcat的访问地址就ok了,这样只要你上传了代码,并且是配置编译的分支,一般过几分钟就会自动编译然后部署到Tomcat中了,当然最好还是用git,然后通过GitLab实现,这样不仅不用每隔几分钟查询一次,而且延迟很小!!

使用Docker搭建 Java Web运行环境

Docker 是 2014 年最为火爆的技术之一,几乎所有的程序员都听说过它。Docker 是一种“轻量级”容器技术,它几乎动摇了传统虚拟化技术的地位,现在国内外已经有越来越多的公司开始逐步使用 Docker 来替换现有的虚拟化平台了。作为一名 Java 程序员,我们是时候一起把 Docker 学起来了!

本文会对虚拟化技术与 Docker 容器技术做一个对比,然后引出一些 Docker 的名词术语,比如:容器、镜像等,随后将使用 Docker 搭建一个 Java Web 运行环境,最后将对本文做一个总结。

我们先来回顾一下传统虚拟化技术的体系架构:

未分类

可见,我们在宿主机的操作系统上,可安装了多个虚拟机,而在每个虚拟机中,通过虚拟化技术,实现了一个虚拟操作系统,随后,就可以在该虚拟操作系统上,安装自己所需的应用程序了。这一切看似非常简单,但其中的技术细节是相当高深莫测的,大神级人物都不一定说得清楚。

凡是使用过虚拟机的同学,应该都知道,启动虚拟机就像启动一台计算机,初始化过程是相当慢的,我们需要等很久,才能看到登录界面。一旦虚拟机启动以后,就可以与宿主机建立网络连接,确保虚拟机与宿主机之间是互联互通的。不同的虚拟机之间却是相互隔离的,也就是说,彼此并不知道对方的存在,但每个虚拟机占用的都是宿主机的硬件与网络资源。

我们再来对比一下 Docker 技术的体系架构吧:

未分类

可见,在宿主机的操作系统上,有一个 Docker 服务在运行(或者称为“Docker 引擎”),在此服务上,我们可开启多个 Docker 容器,而每个 Docker 容器中可运行自己所需的应用程序,Docker 容器之间也是相互隔离的,同样地,都是占用的宿主机的硬件与网络资源。

Docker 容器相对于虚拟机而言,除了在技术实现上完全不一样以外,启动速度较虚拟机而言有本质的飞跃,启动一个容器只在眨眼瞬间。不管是虚拟机还是 Docker 容器,它们都是为了隔离应用程序的运行环境,节省我们的硬件资源,为我们开发人员提供福利。

我们再来看看 Docker 的 Logo 吧:

未分类

很明显,这是一只鲸鱼,它托着许多集装箱。我们可以把宿主机可当做这只鲸鱼,把相互隔离的容器可看成集装箱,每个集装箱中都包含自己的应用程序。这 Logo 简直的太形象了!

需要强调的是,笔者并非否定虚拟化技术,而是想通过本文让更多的读者了解如何使用 Docker 技术,让大家知道除了虚拟化技术以外,还有另一种替代技术,也能让应用程序隔离起来。

下面,我们将结合一个 Java Web 应用的部署过程,来描述如何“烹饪”Docker 这份美味佳肴。您准备好了吗?我们现在就开始!

原料

前提条件

首先,您要准备一个 CentOS 的操作系统,虚拟机也行。总之,可以通过 Linux 客户端工具访问到 CentOS 操作系统就行。

需要说明的是,Ubuntu 或其它 Linux 操作系统也能玩 Docker,只不过本文选择了以 CentOS 为例,仅此而已。

CentOS 具体要求如下:

  • 必须是 64 位操作系统
  • 建议内核在 3.8 以上

通过以下命令查看您的 CentOS 内核:

uname -r

如果执行以上命令后,输出的内核版本号低于 3.8,请参考下面的方法来来升级您的 Linux 内核。

对于 CentOS 6.5 而言,内核版本默认是 2.6。首先,可通过以下命令安装最新内核:

rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
rpm -ivh http://www.elrepo.org/elrepo-release-6-5.el6.elrepo.noarch.rpm
yum -y --enablerepo=elrepo-kernel install kernel-lt

随后,编辑以下配置文件:

vi /etc/grub.conf

将default=1修改为default=0。

最后,通过reboot命令重启操作系统。

重启后如果不出意外的话,再次查看内核,您的 CentOS 内核将会显示为 3.10。

如果到这里,您和我们所期望的结果是一致的。恭喜您!下面我们就一起来安装 Docker 了。

安装 Docker

只需通过以下命令即可安装 Docker 软件:

rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
yum -y install docker-io

可使用以下命令,查看 Docker 是否安装成功:

docker version

若输出了 Docker 的版本号,则说明安装成功,我们下面就可以开始使用 Docker 了。

可通过以下命令启动 Docker 服务:

service docker start

做法

就像曾经安装软件一样,我们首先需要有一张刻录了该软件的光盘,如果您使用的是虚拟光驱,那么就需要运行一种名为“镜像”的文件,通过它来安装软件。在 Docker 的世界里,也有一个名为“镜像”的东西,已经安装我们所需的操作系统,我们一般成为“Docker 镜像”,本文简称“镜像”。

那么问题来了,我们从哪里下载镜像呢?

Docker 官网 确实已经提供了所有的镜像下载地址,可惜在国内却是无法访问的。幸好国内好心人提供了一个 Docker 中文网,在该网站上可以下载我们所需的 Docker 镜像。

下载镜像

我们不妨还是以 CentOS 为例,通过以下步骤,下载一个 CentOS 的镜像。

首先,访问 Docker 中文网,在首页中搜索名为“centos”的镜像,在搜索的结果中,有一个“官方镜像”,它就是我们所需的。

然后,进入 CentOS 官方镜像页面,在“Pull this repository”输入框中,有一段命令,把它复制下来,在自己的命令行上运行该命令,随后将立即下载该镜像。

最后,使用以下命令查看本地所有的镜像:

docker images

当下载完成后,您应该会看到:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
docker.cn/docker/centos   centos6             25c5298b1a36        7 weeks ago         215.8 MB

如果看到以上输出,说明您可以使用“docker.cn/docker/centos”这个镜像了,或将其称为仓库(Repository),该镜像有一个名为“centos6”的标签(Tag),此外还有一个名为“25c5298b1a36 ”的镜像 ID(可能您所看到的镜像 ID 与此处的不一致,那是正常现象,因为这个数字是随机生成的)。此外,我们可以看到该镜像只有 215.8 MB,非常小巧,而不像虚拟机的镜像文件那样庞大。

现在镜像已经有了,我们下面就需要使用该镜像,来启动容器。

启动容器

容器是在镜像的基础上来运行的,一旦容器启动了,我们就可以登录到容器中,安装自己所需的软件或应用程序。既然镜像已经下载到本地,那么如何才能启动容器呢?

只需使用以下命令即可启动容器:

docker run -i -t -v /root/software/:/mnt/software/ 25c5298b1a36 /bin/bash

这条命令比较长,我们稍微分解一下,其实包含以下三个部分:

docker run <相关参数> <镜像 ID> <初始命令>

其中,相关参数包括:

  • -i:表示以“交互模式”运行容器
  • -t:表示容器启动后会进入其命令行
  • -v:表示需要将本地哪个目录挂载到容器中,格式:-v :

假设我们的所有安装程序都放在了宿主机的/root/software/目录下,现在需要将其挂载到容器的/mnt/software/目录下。

需要说明的是,不一定要使用“镜像 ID”,也可以使用“仓库名:标签名”,例如:docker.cn/docker/centos:centos6。

初始命令表示一旦容器启动,需要运行的命令,此时使用“/bin/bash”,表示什么也不做,只需进入命令行即可。

安装相关软件

为了搭建 Java Web 运行环境,我们需要安装 JDK 与 Tomcat,下面的过程均在容器内部进行。我们不妨选择/opt/目录作为安装目录,首先需要通过cd /opt/命令进入该目录。

安装 JDK

首先,解压 JDK 程序包:

tar -zxf /mnt/software/jdk-7u67-linux-x64.tar.gz -C .

然后,重命名 JDK 目录:

mv jdk1.7.0_67/ jdk/

安装 Tomcat

首先,解压 Tomcat 程序包:

tar -zxf /mnt/software/apache-tomcat-7.0.55.tar.gz -C .

然后,重命名 Tomcat 目录:

mv apache-tomcat-7.0.55/ tomcat/

设置环境变量

首先,编辑.bashrc文件

vi ~/.bashrc

然后,在该文件末尾添加如下配置:

export JAVA_HOME=/opt/jdk
export PATH=$PATH:$JAVA_HOME

最后,需要使用source命令,让环境变量生效:

source ~/.bashrc

编写运行脚本

我们需要编写一个运行脚本,当启动容器时,运行该脚本,启动 Tomcat,具体过程如下:

首先,创建运行脚本:

vi /root/run.sh

然后,编辑脚本内容如下:

#!/bin/bash
source ~/.bashrc
sh /opt/tomcat/bin/catalina.sh run

注意:这里必须先加载环境变量,然后使用 Tomcat 的运行脚本来启动 Tomcat 服务。

最后,为运行脚本添加执行权限:

chmod u+x /root/run.sh

退出容器

当以上步骤全部完成后,可使用exit命令,退出容器。

随后,可使用如下命令查看正在运行的容器:

docker ps

此时,您应该看不到任何正在运行的程序,因为刚才已经使用exit命令退出的容器,此时容器处于停止状态,可使用如下命令查看所有容器:

docker ps -a

输出如下内容:

CONTAINER ID        IMAGE                             COMMAND             CREATED             STATUS                      PORTS               NAMES
57c312bbaad1        docker.cn/docker/centos:centos6   "/bin/bash"         27 minutes ago      Exited (0) 19 seconds ago                       naughty_goldstine

记住以上CONTAINER ID(容器 ID),随后我们将通过该容器,创建一个可运行 Java Web 的镜像。

创建 Java Web 镜像

使用以下命令,根据某个“容器 ID”来创建一个新的“镜像”:

docker commit 57c312bbaad1 huangyong/javaweb:0.1

该容器的 ID 是“57c312bbaad1”,所创建的镜像名是“huangyong/javaweb:0.1”,随后可使用镜像来启动 Java Web 容器。

启动 Java Web 容器

有必要首先使用docker images命令,查看当前所有的镜像:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
huangyong/javaweb         0.1                 fc826a4706af        38 seconds ago      562.8 MB
docker.cn/docker/centos   centos6             25c5298b1a36        7 weeks ago         215.8 MB

可见,此时已经看到了最新创建的镜像“huangyong/javaweb:0.1”,其镜像 ID 是“fc826a4706af”。正如上面所描述的那样,我们可以通过“镜像名”或“镜像 ID”来启动容器,与上次启动容器不同的是,我们现在不再进入容器的命令行,而是直接启动容器内部的 Tomcat 服务。此时,需要使用以下命令:

docker run -d -p 58080:8080 --name javaweb huangyong/javaweb:0.1 /root/run.sh

稍作解释:

  • -d:表示以“守护模式”执行/root/run.sh脚本,此时 Tomcat 控制台不会出现在输出终端上。
  • -p:表示宿主机与容器的端口映射,此时将容器内部的 8080 端口映射为宿主机的 58080 端口,这样就向外界暴露了 58080 端口,可通过 Docker 网桥来访问容器内部的 8080 端口了。
  • –name:表示容器名称,用一个有意义的名称命名即可。

关于 Docker 网桥的内容,需要补充说明一下。实际上 Docker 在宿主机与容器之间,搭建了一座网络通信的桥梁,我们可通过宿主机 IP 地址与端口号来映射容器内部的 IP 地址与端口号,

在一系列参数后面的是“镜像名”或“镜像 ID”,怎么方便就怎么来。最后是“初始命令”,它是上面编写的运行脚本,里面封装了加载环境变量并启动 Tomcat 服务的命令。

当运行以上命令后,会立即输出一长串“容器 ID”,我们可通过docker ps命令来查看当前正在运行的容器。

CONTAINER ID        IMAGE                   COMMAND             CREATED             STATUS              PORTS                     NAMES
82f47923f926        huangyong/javaweb:0.1   "/root/run.sh"      4 seconds ago       Up 3 seconds        0.0.0.0:58080->8080/tcp   javaweb

品尝

在浏览器中,输入以下地址,即可访问 Tomcat 首页:

http://192.168.65.132:58080/

注意:这里使用的是宿主机的 IP 地址,与对外暴露的端口号 58080,它映射容器内部的端口号 8080。

总结

通过本文,我们了解了 Docker 是什么?它与虚拟机的差别在哪里?以及如何安装 Docker?如何下载 Docker 镜像?如何运行 Docker 容器?如何在容器内安装应用程序?如何在容器上创建镜像?如何以服务的方式启动容器?这一切看似简单,但操作也是相当繁琐的,不过熟能生巧,需要我们不断地操练。

除了这种手工生成 Docker 镜像的方式以外,还有一种更像是写代码一样,可以自动地创建 Docker 镜像的方式。只需要我们编写一个 Dockerfile 文件,随后使用docker build命令即可完成以上所有的手工操作。