kubernetes下的Nginx加Tomcat三部曲之二：細說開發

時間  2019-11-20
標籤 kubernetes nginx tomcat 三部曲 之二 細說 開發 欄目 Nginx 简体版
原文   原文鏈接

本文是《kubernetes下的Nginx加Tomcat三部曲》的第二章，在《kubernetes下的Nginx加Tomcat三部曲之一：極速體驗》一文咱們快速部署了Nginx和Tomcat，達到如下效果： 
這裏寫圖片描述html

本文我會詳細說明在kubernetes部署上述網絡服務時，須要作哪些具體的工做；java

列舉步驟

須要如下操作才能在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的腳本node

腳本文件下載

本次體驗所需的deployment和service資源是經過腳本建立的，這個腳本能夠經過如下兩種方式中的任意一種下載： 
1. CSDN下載(沒法設置免費下載，只能委屈您用掉兩個積分了)：http://download.csdn.net/download/boling_cavalry/10235034 
2. GitHub下載，地址和連接信息以下表所示：nginx

名稱 連接 備註
項目主頁 https://github.com/zq2599/blog_demos 該項目在GitHub上的主頁
git倉庫地址(https) https://github.com/zq2599/blog_demos.git 該項目源碼的倉庫地址，https協議
git倉庫地址(ssh) git@github.com:zq2599/blog_demos.git 該項目源碼的倉庫地址，ssh協議


這個git項目中有多個目錄，本次所需的資源放在k8s_nginx_tomcat_resource，以下圖紅框所示：git

這裏寫圖片描述

下到的k8stomcatcluster20180201.tar是個壓縮包，複製到能夠執行kubectl命令的ubuntu電腦上，而後解壓開，是個名爲k8stomcatcluster的文件夾；github

Spring boot的web工程源碼下載

GitHub下載，地址和連接信息以下表所示：web

名稱 連接 備註
項目主頁 https://github.com/zq2599/blog_demos 該項目在GitHub上的主頁
git倉庫地址(https) https://github.com/zq2599/blog_demos.git 該項目源碼的倉庫地址，https協議
git倉庫地址(ssh) git@github.com:zq2599/blog_demos.git 該項目源碼的倉庫地址，ssh協議


這個git項目中有多個目錄，本次的web工程源碼放在k8stomcatdemo，以下圖紅框所示：spring

這裏寫圖片描述

接下來咱們開始實戰開發吧；docker

開發環境

本次實戰開發環境的具體信息以下： 
1. 操做系統：Ubuntu16； 
2. Docker版本：17.03.2-ce； 
3. JDK：1.8.0_151； 
4. maven：3.3.3；shell

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鏡像的細節，請看《maven構建docker鏡像三部曲之二：編碼和構建鏡像》；

讓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私有倉庫，例如搭建局域網私有倉庫或者阿里雲私有倉庫，參考《maven構建docker鏡像三部曲之三：推送到遠程倉庫(內網和阿里雲)》；

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地址； 
2. 服務對外暴露了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 <zq2599@gmail.com>

#定義工做目錄
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 <zq2599@gmail.com>
 ---> 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環境的全部資源，您就能夠用這些像《kubernetes下的Nginx加Tomcat三部曲之一：極速體驗》文中那樣去搭建和體驗kubernetes下的Nginx加Tomcat；

下一章，咱們會在此環境的基礎上實戰Tomcat服務的擴容，並修改web工程的代碼，再建立新的鏡像，而且將kubernetes環境下在線升級新的web工程服務；

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程