月份：2018年2月

本章是《kubernetes下的Nginx加Tomcat三部曲系列》的终篇，今天咱们一起在kubernetes环境对下图中tomcat的数量进行调整，再修改tomcat中web工程的源码，并将现有的tomcat的pod全部替换成新代码构建的结果：

往期章节

1. kubernetes下的Nginx加Tomcat三部曲之一： http://devops.webres.wang/2018/02/kubernetes%E4%B8%8B%E7%9A%84nginx%E5%8A%A0tomcat%E4%B8%89%E9%83%A8%E6%9B%B2%E4%B9%8B%E4%B8%80%EF%BC%9A%E6%9E%81%E9%80%9F%E4%BD%93%E9%AA%8C/
2. kubernetes下的Nginx加Tomcat三部曲之二： http://devops.webres.wang/2018/02/kubernetes%E4%B8%8B%E7%9A%84nginx%E5%8A%A0tomcat%E4%B8%89%E9%83%A8%E6%9B%B2%E4%B9%8B%E4%BA%8C%EF%BC%9A%E7%BB%86%E8%AF%B4%E5%BC%80%E5%8F%91/

列举步骤

1. 在线扩容Tomcat；
2. 验证扩容结果；
3. 修改web工程源码；
4. 构建web工程的新镜像；
5. 让kubernetes的机器用上web工程的Docker镜像
6. 在线更新Tomcat的pod的镜像；
7. 验证更新结果；
8. Nginx&Tomcat方式和SpringCloud方式扩容对比；

kubernetes环境基本情况

1. 一个master，一个node；
2. master的IP地址：192.168.119.148；
3. node1的IP地址：192.168.119.153；

在线扩容Tomcat

• 在装好kubectl工具的机器上执行kubectl get pods，查看当前pod情况：

root@master:~# kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
ng-59b887b8bc-jzcv5           1/1       Running   3          2d
tomcathost-7f68566795-8pl29   1/1       Running   3          2d
tomcathost-7f68566795-mvg5f   1/1       Running   3          2d
tomcathost-7f68566795-trscg   1/1       Running   3          2d

如上所示，目前是三个tomcat的pod；

• 执行扩容命令kubectl scale deployment tomcathost –replicas=5，将tomcat的pod从3个增加到5个，如下：

root@master:~# kubectl scale deployment tomcathost --replicas=5
deployment "tomcathost" scaled
root@master:~# kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
ng-59b887b8bc-jzcv5           1/1       Running   3          2d
tomcathost-7f68566795-8kf76   1/1       Running   0          18s
tomcathost-7f68566795-8pl29   1/1       Running   3          2d
tomcathost-7f68566795-mvg5f   1/1       Running   3          2d
tomcathost-7f68566795-tp5xp   1/1       Running   0          18s
tomcathost-7f68566795-trscg   1/1       Running   3          2d

tomcat的pod已经增加到5个了，创建时间都只有18秒；

• 去dashboard页面看以下tomcathost这个deployment的详情，可以看到tomcat数量已经上升到5个了，扩容成功：

点击上图红框1，再点击tomcathost这个服务，可以看到上图中的详情；
上图红框2中是5个tomcat的pod的容器IP地址；
点击上图红框3中的每个容器名，可以查看容器详情；
上图红框4显示了刚才的扩容事件；

验证扩容结果

nginx服务所在的node机器的IP地址是192.168.119.153，所以在浏览器上访问：http://192.168.119.153:30006/getserverinfo，反复刷新此页面，看到返回的IP地址在不断的更新，都是tomcat所在pod的IP地址，5个都会出现，如下图：

扩容实战就到这里，接下来我们修改web工程的源码，验证在线升级的能力；

修改web工程源码

tomcat上运行的web工程源码，可以GitHub下载，地址和链接信息如下表所示：

这个git项目中有多个目录，本次的web工程源码放在k8stomcatdemo，如下图红框所示：

• 打开工程中的ServerInfo.java，web接口的源码如下：

@RequestMapping(value = "/getserverinfo", method = RequestMethod.GET)
    public String getUserInfoWithRequestParam(){
        return String.format("server : %s, time : %s", getIPAddr(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

• 修改返回的字符串内容，在前面加上”From new version,”：

@RequestMapping(value = "/getserverinfo", method = RequestMethod.GET)
    public String getUserInfoWithRequestParam(){
        return String.format("From new version, server : %s, time : %s", getIPAddr(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

构建web工程的新镜像

修改pom.xml中的工程版本，从0.0.1-SNAPSHOT改为0.0.3，如下所示：

<groupId>com.bolingcavalry</groupId>
    <artifactId>k8stomcatdemo</artifactId>
    <version>0.0.3</version>
    <packaging>jar</packaging>
    <name>k8stomcatdemo</name>

• 在pom.xml所在目录执行mvn clean package -DskipTests docker:build，会编译构建工程，并且在本地制作好镜像文件，如下：

root@maven:/usr/local/work/k8s/k8stomcatdemo# docker images
REPOSITORY                                              TAG                 IMAGE ID            CREATED             SIZE
bolingcavalry/k8stomcatdemo                             0.0.3               5f2d27eafd1b        17 seconds ago      658 MB
bolingcavalry/k8stomcatdemo                             latest              5f2d27eafd1b        17 seconds ago      658 MB

让kubernetes的机器用上web工程的Docker镜像

现在的镜像只存在于开发和构建web工程的电脑上，为了让kubernetes的node机器能用上这个镜像，可以用以下几种方式实现：

1、用docker push命令将本机镜像推送到hub.docker.com网站，这样其他机器都可以通过docker pull命令取得了，我就是用的这种方法，需要在hub.docker.com上注册，下图是正在push中：

2、用docker save命令导出镜像文件，再用docker load命令导入；
3、kubernetes所在机器安装java和maven环境，将工程在这里编译构建；
4、使用docker私有仓库，例如搭建局域网私有仓库或者阿里云私有仓库，参考 http://blog.csdn.net/boling_cavalry/article/details/78934391

在线更新Tomcat的pod的镜像

• 在kubernetes上执行以下命令，即可升级镜像，当前的5个tomcat的pod会被销毁，然后用新的镜像创建pod：

kubectl set image deployment/tomcathost tomcathost=bolingcavalry/k8stomcatdemo:0.0.3

• 控制台提示的信息如下：

root@maven:/usr/local/work/k8s/k8stomcatdemo# kubectl set image deployment/tomcathost tomcathost=bolingcavalry/k8stomcatdemo:0.0.3
deployment "tomcathost" image updated

• 此刻反复执行kubectl get pod，会看到新容器创建，旧容器正在被销毁，如下：

root@maven:/usr/local/work/k8s/k8stomcatdemo# kubectl get pod
NAME                          READY     STATUS              RESTARTS   AGE
ng-59b887b8bc-jzcv5           1/1       Running             3          2d
tomcathost-6dfc87dc8b-9bkfv   1/1       Running             0          50s
tomcathost-6dfc87dc8b-h6gx4   0/1       ContainerCreating   0          50s
tomcathost-6dfc87dc8b-ht2d8   1/1       Running             0          18s
tomcathost-6dfc87dc8b-pfb56   1/1       Running             0          10s
tomcathost-6dfc87dc8b-x8pnn   1/1       Running             0          14s
tomcathost-7f68566795-8pl29   0/1       Terminating         3          2d
tomcathost-7f68566795-trscg   0/1       Terminating         3          2d

验证更新结果

• nginx服务所在的node机器的IP地址是192.168.119.153，所以在浏览器上访问：http://192.168.119.153:30006/getserverinfo，可以看到”From new version”这个字符串，如下图：

去dashboard页面看服务详情，可以看见一系列的缩容和扩容事件，如下图：

Nginx&Tomcat方式和SpringCloud方式扩容对比

在之前的文章中，我们实战了SpringCloud环境下服务提供方的扩容，由于是“注册&发现”的方式，扩容只需要往SpringCloud环境添加provider机器，不需要做什么设置，请求就会被落到新的provider上，相关实战的地址如下：

1. Docker下的Spring Cloud三部曲之一： http://blog.csdn.net/boling_cavalry/article/details/79177930

2. Docker下的Spring Cloud三部曲之二: http://blog.csdn.net/boling_cavalry/article/details/79134497

3. Docker下的Spring Cloud三部曲之三： http://blog.csdn.net/boling_cavalry/article/details/79192376

在Nginx加Tomcat环境中，如果不是在kubernetes环境，我们增加Tomcat之后需要修改Nginx配置，否则到达Nginx的请求不会被转发到新的机器上去，幸运的是kubernete帮我们解决了这个问题，扩容缩容都只需要控制副本数即可，不用修改Nginx配置了；

doceker-compose虽然可以修改副本数，但是Nginx的配置仍然需要修改，否则新创建的Tomcat容器都有自己的IP地址，Nginx还是感知不到；

至此，kubernetes下的Nginx加Tomcat三部曲就全部结束了，希望能在您的kubernetes实战中有所帮助；

本文是《kubernetes下的Nginx加Tomcat三部曲》的第二章，在 http://devops.webres.wang/2018/02/kubernetes%E4%B8%8B%E7%9A%84nginx%E5%8A%A0tomcat%E4%B8%89%E9%83%A8%E6%9B%B2%E4%B9%8B%E4%B8%80%EF%BC%9A%E6%9E%81%E9%80%9F%E4%BD%93%E9%AA%8C/ 一文我们快速部署了Nginx和Tomcat，达到以下效果：

本文我会详细说明在kubernetes部署上述网络服务时，需要做哪些具体的工作；

列举步骤

需要以下操做才能在kubernetes上部署Nginx加Tomcat的服务：

1. 开发Tomcat上的web工程和Docker镜像；
2. 让kubernetes的机器用上web工程的Docker镜像；
3. 开发Tomcat对应的deployment脚本；
4. 开发Tomcat对应的service脚本；
5. 开发Nginx对应的Docker镜像；
6. 让kubernetes的机器用上Nginx的Docker镜像
7. 开发Nginx对应的deployment脚本；
8. 开发Nginx对应的service脚本；
9. 开发启动上述pod和service的脚本；
10. 开发停止并清除上述pod和service的脚本

脚本文件下载

本次体验所需的deployment和service资源是通过脚本创建的，这个脚本可以通过以下两种方式中的任意一种下载：

1. CSDN下载(无法设置免费下载，只能委屈您用掉两个积分了)：http://download.csdn.net/download/boling_cavalry/10235034
2. GitHub下载，地址和链接信息如下表所示：

这个git项目中有多个目录，本次所需的资源放在k8s_nginx_tomcat_resource，如下图红框所示：

下到的k8stomcatcluster20180201.tar是个压缩包，复制到可以执行kubectl命令的ubuntu电脑上，然后解压开，是个名为k8stomcatcluster的文件夹；

Spring boot的web工程源码下载

GitHub下载，地址和链接信息如下表所示：

这个git项目中有多个目录，本次的web工程源码放在k8stomcatdemo，如下图红框所示：

接下来我们开始实战开发吧；

开发环境

本次实战开发环境的具体信息如下：

1. 操作系统：Ubuntu16；
2. Docker版本：17.03.2-ce；
3. JDK：1.8.0_151；
4. maven：3.3.3；

Tomcat上的web工程和Docker镜像

web工程用来提供http服务，返回当前机器的IP地址给浏览器，完整源码请参照前面下载的k8stomcatdemo工程，这里我们还是重新创建一次；

1、创建一个springboot工程，pom.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bolingcavalry</groupId>
    <artifactId>k8stomcatdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>k8stomcatdemo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <!--新增的docker maven插件-->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>0.4.12</version>
                <!--docker镜像相关的配置信息-->
                <configuration>
                    <!--镜像名，这里用工程名-->
                    <imageName>bolingcavalry/${project.artifactId}</imageName>
                    <!--TAG,这里用工程版本号-->
                    <imageTags>
                        <imageTag>${project.version}</imageTag>
                    </imageTags>
                    <!--镜像的FROM，使用java官方镜像-->
                    <baseImage>java:8u111-jdk</baseImage>
                    <!--该镜像的容器启动后，直接运行spring boot工程-->
                    <entryPoint>["java", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
                    <!--构建镜像的配置信息-->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

可以看到这是个普通的springboot的web工程，唯一不同的是多了一个maven插件：docker-maven-plugin，使用该插件我们可以将maven工程制作成docker镜像；

2、整个工程只有一个Controller，开通一个http接口，将当前服务器IP地址返回，源码如下：

@RestController
public class ServerInfo {

    @RequestMapping(value = "/getserverinfo", method = RequestMethod.GET)
    public String getUserInfoWithRequestParam(){
        return String.format("server : %s, time : %s", getIPAddr(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

    /**
     * 获取本机IP地址
     * @return
     */
    private static String getIPAddr(){
        String hostAddress = null;
        try{
            InetAddress address = InetAddress.getLocalHost();
            hostAddress = address.getHostAddress();
        }catch (UnknownHostException e){
            e.printStackTrace();
        }

        return hostAddress;
    }
}

以上就是工程的关键源码；

3、在pom.xml所在目录执行mvn clean package -DskipTests docker:build，会编译构建工程，并且在本地制作好镜像文件，如下：

root@maven:/usr/local/work/github/blog_demos# docker images
REPOSITORY                                              TAG                 IMAGE ID            CREATED             SIZE
bolingcavalry/k8stomcatdemo                             latest              1d41d9980a0b        43 hours ago        658 MB
bolingcavalry/k8stomcatdemo                             0.0.1-SNAPSHOT      c91bc368a729        46 hours ago        658 MB

想了解更多maven制作docker镜像的细节，请看 http://blog.csdn.net/boling_cavalry/article/details/78872020

让kubernetes的机器用上web工程的Docker镜像

现在的镜像只存在于开发和构建web工程的电脑上，为了让kubernetes的node机器能用上这个镜像，可以用以下几种方式实现：

1. 用docker push命令将本机镜像推送到hub.docker.com网站，这样其他机器都可以通过docker pull命令取得了，我就是用的这种方法，需要在hub.docker.com上注册；
2. 用docker save命令导出镜像文件，再用docker load命令导入；
3. kubernetes所在机器安装java和maven环境，将工程在这里编译构建；
4. 使用docker私有仓库，例如搭建局域网私有仓库或者阿里云私有仓库，参考 http://blog.csdn.net/boling_cavalry/article/details/78934391

Tomcat对应的deployment脚本

用yaml文件将详情配置好，再用kubectl命令执行这个配置就能创建pod，这个web应用镜像的配置文件名为tomcat.yaml，内容如下：

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: tomcathost
spec:
  replicas: 3
  template:
    metadata:
     labels:
       name: tomcathost
    spec:
     containers:
     - name: tomcathost
       image: bolingcavalry/k8stomcatdemo:0.0.1-SNAPSHOT
       tty: true
       ports:
       - containerPort: 8080

将上述脚本的几个关键点列举一下：

1. version用extensions/v1beta1；
2. kind用Deployment，支持升级镜像和滚动升级；
3. 使用的镜像bolingcavalry/k8stomcatdemo:0.0.1-SNAPSHOT，是我从本地push到hub.docker.com上去的；
4. 创建的容器对外暴露了8080端口；

Tomcat对应的service脚本

创建了tomcat的pod之后，为了能在kubernetes环境中给其他service使用，需要将这些pod包装为service，这里是通过tomcat-svc.yaml文件来配置的，内容如下：

apiVersion: v1
kind: Service
metadata:
  name: tomcathost
spec:
  type: ClusterIP
  ports:
       - port: 8080
  selector:
    name: tomcathost

将上述脚本的几个关键点列举一下：

1. 服务对应的pod是tomcathost；
2. type用ClusterIP，为内部service调用提供统一IP地址；
3. 服务对外暴露了pod的8080端口；

Nginx对应的Docker镜像

• 定制的Nginx镜像和Nginx官方镜像相比，唯一的区别就是nginx.conf文件不同，我们用的nginx.conf内容如下：

user  nginx;
worker_processes  1;

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


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    #include /etc/nginx/conf.d/*.conf;

    upstream tomcat_client {
         server tomcathost:8080;
    } 

    server {
        server_name "";
        listen 80 default_server;
        listen [::]:80 default_server ipv6only=on;

        location / {
            proxy_pass http://tomcat_client;
            proxy_redirect default;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

以上配置中，新增的upstream对应的IP地址是tomcathost，这是tomcat的service名称，在Nginx运行的时候，通过tomcathost就能访问到tomcat的Pod；

• 制作Docker镜像的Dockerfile文件内容如下，每行都有注释就不再多说了：

# First docker file from bolingcavalry
# VERSION 0.0.1
# Author: bolingcavalry

#基础镜像
FROM nginx:stable

#作者
MAINTAINER BolingCavalry <[email protected]>

#定义工作目录
ENV WORK_PATH /etc/nginx

#定义conf文件名
ENV CONF_FILE_NAME nginx.conf

#删除原有配置文件
RUN rm $WORK_PATH/$CONF_FILE_NAME

#复制新的配置文件
COPY ./$CONF_FILE_NAME $WORK_PATH/

#给shell文件赋读权限
RUN chmod a+r $WORK_PATH/$CONF_FILE_NAME

将nginx.conf和Dockerfile放在同一个目录，然后执行命令docker build -t bolingcavalry/nginx-with-tomcat-host:0.0.1 .，就能构建镜像文件了，如下:

root@maven:/usr/local/work/nginx# docker build -t bolingcavalry/nginx-with-tomcat-host:0.0.1 .
Sending build context to Docker daemon 14.51 MB
Step 1/7 : FROM nginx:stable
 ---> dfe062ee1dc8
Step 2/7 : MAINTAINER BolingCavalry <[email protected]>
 ---> Using cache
 ---> 93f4bf154c55
Step 3/7 : ENV WORK_PATH /etc/nginx
 ---> Using cache
 ---> d0158757fc9c
Step 4/7 : ENV CONF_FILE_NAME nginx.conf
 ---> Using cache
 ---> 7a18a8b417d6
Step 5/7 : RUN rm $WORK_PATH/$CONF_FILE_NAME
 ---> Using cache
 ---> f6f27d25539d
Step 6/7 : COPY ./$CONF_FILE_NAME $WORK_PATH/
 ---> Using cache
 ---> 33075a2b0379
Step 7/7 : RUN chmod a+r $WORK_PATH/$CONF_FILE_NAME
 ---> Using cache
 ---> 58ce530e160b
Successfully built 58ce530e160b

让kubernetes的机器用上Nginx的Docker镜像

这一步和之前的web工程的镜像放到kubernetes一样，有多种方式，我用的还是通过docker push推送到hub.docker.com网站，再在kubernetes上pull下来；

Nginx对应的deployment脚本

用yaml文件将详情配置好，再用kubectl命令执行这个配置就能创建pod，这个web应用镜像的配置文件名为nginx.yaml，内容如下：

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: ng
spec:
  replicas: 1
  template:
    metadata:
     labels:
      name: ng
    spec:
     containers:
     - name: ng
       image: bolingcavalry/nginx-with-tomcat-host:0.0.1
       ports:
       - containerPort: 80

以上配置中有几点要注意：

1. 使用镜像是刚才创建的nginx镜像bolingcavalry/nginx-with-tomcat-host:0.0.1；
2. pod容器创建后，对外暴露80端口；

Nginx对应的service脚本

通过service定义的yaml文件nginx-svc.yam，将前面创建的nginx的pod包装为service：

apiVersion: v1
kind: Service
metadata:
  name: ng
spec:
  type: NodePort
  ports:
       - port: 80
         nodePort: 30006
  selector:
    name: ng

以上配置中有几点要注意：

1. type使用NodePort，这样可以通过节点机器的IP访问此service；
2. 将节点机器的30006端口和pod的80端口绑定，因此，外部访问节点IP+30006端口就能访问到此Nginx服务了；

启动上述pod和service的脚本

接下来我们创建一个shell脚本start_all.sh，将上述的tomcat和nginx的pod以及service全部创建和启动：

kubectl create -f tomcat.yaml
kubectl create -f tomcat-svc.yaml
kubectl create -f nginx.yaml
kubectl create -f nginx-svc.yaml
echo ""
echo "nginx and tomcat running now"

如上所示，通过kubectl create -f加文件名，就能创建好yaml文件中定义的pod和service；

停止并清除上述pod和service的脚本

创建一个shell脚本stop_all.sh，能够将上述的tomcat和nginx的pod以及service全部清除掉：

kubectl delete service tomcathost
kubectl delete deployment tomcathost
kubectl delete service ng
kubectl delete deployment ng
echo "nginx and tomcat stop now"

如上所示，其实就是通过kubectl delete命令将指定的pod和service资源删除；

以上就是在kubernetes搭建整个Nginx加Tomcat环境的所有资源，您就可以用这些像 http://devops.webres.wang/2018/02/kubernetes%E4%B8%8B%E7%9A%84nginx%E5%8A%A0tomcat%E4%B8%89%E9%83%A8%E6%9B%B2%E4%B9%8B%E4%B8%80%EF%BC%9A%E6%9E%81%E9%80%9F%E4%BD%93%E9%AA%8C/ 文中那样去搭建和体验kubernetes下的Nginx加Tomcat；

下一章，我们会在此环境的基础上实战Tomcat服务的扩容，并修改web工程的代码，再创建新的镜像，并且将kubernetes环境下在线升级新的web工程服务；

章节介绍

在生产环境中，常用到Nginx加Tomcat的部署方式，如下图：

从本章开始，我们来实战kubernetes下部署上述Nginx和Tomcat服务，并开发spring boot的web应用来验证环境，整个实战分为以下三篇内容：

1. 极速体验kubernetes下的nginx加tocmat；
2. 细说nginx和tomcat镜像的制作；
3. 实战tomcat server的在线扩容和应用升级；

实战工程介绍

本次实战创建的Pod如下：

1. 一个Nginx的Pod，负责转发web请求到Tomcat；
2. 三个Tomcat的Pod，上面部署了web应用，收到Nginx转发的请求后，返回的内容是当前Pod的IP地址；

准备kubernetes环境

本次实战需要可用的kubernetes环境，您可以参考以下文章进行快速搭建：

1. http://blog.csdn.net/boling_cavalry/article/details/78762829
2. http://blog.csdn.net/boling_cavalry/article/details/78764915

如何执行kubectl命令

实战中，需要在一台ubuntu电脑上安装kubectl工具，然后连接到kubernetes环境执行各种命令，kubectl工具的安装步骤可以参照这篇文章： http://blog.csdn.net/boling_cavalry/article/details/79223091

脚本文件下载

本次体验所需的deployment和service资源是通过脚本创建的，这个脚本可以通过以下两种方式中的任意一种下载：

1. CSDN下载(无法设置免费下载，只能委屈您用掉两个积分了)：http://download.csdn.net/download/boling_cavalry/10235034
2. GitHub下载，地址和链接信息如下表所示：

这个git项目中有多个目录，本次所需的资源放在k8s_nginx_tomcat_resource，如下图红框所示：

下到的k8stomcatcluster20180201.tar是个压缩包，复制到可以执行kubectl命令的ubuntu电脑上，然后解压开，是个名为k8stomcatcluster的文件夹；

执行脚本文件下载

1. 进入解压好的k8stomcatcluster目录；
2. 执行命令chmod a+x *.sh，给shell脚本赋可执行权限；3.
   执行命令start_all.sh，创建本次实战的资源，页面输出如下信息：

root@maven:/usr/local/work/k8s/k8stomcatcluster# ./start_all.sh 
deployment "tomcathost" created
service "tomcathost" created
deployment "ng" created
service "ng" created

nginx and tomcat running now

验证服务已经启动

• 先去kubernetes的管理页面看一下服务是否启动，如下图，名为ng、tomcathost的两个服务都已经启动：

• 点击tomcathost服务，看到详情信息，里面有pod的情况，如下图：

• 上图中显示tomcathost是在node1创建的，我的node1机器的IP地址是192.168.119.153，所以在浏览器输入：
  http://192.168.119.153:30006/getserverinfo

• 在浏览器看到的信息如下图所示，机器Tomcat所在机器的IP地址和当前时间：

• 多次刷新页面，能看到这三个IP地址：10.42.38.128、10.42.184.35、10.42.127.135，这就是三个Tomcat Pod的地址，Pod信息如下图红框所示：

• 执行k8stomcatcluster目录下的stop_all.sh脚本，可以将前面创建的所有service，deployment资源删除；

• 至此，我们已经在kubernetes下简单体验了Nginx加Tomcat的网站结构，接下来的章节，我们一起来细看如何在kubernetes下创建整个环境；