### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

### 本篇概覽
- 本文是《kubernetes下的Nginx加Tomcat三部曲》的第二章，在[《kubernetes下的Nginx加Tomcat三部曲之一：極速體驗》](http://blog.itpub.net/70017844/viewspace-2895291/)一文我們快速部署了Nginx和Tomcat，達到以下效果：
![這裡寫圖片描述](https://img-blog.csdnimg.cn/img_convert/88efbe2a63636fd89267b435ec7fd711.png)

- 本文我會詳細說明在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資源是透過指令碼建立的，這個指令碼可以透過GitHub下載，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| 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，如下圖紅框所示：

![這裡寫圖片描述](https://img-blog.csdnimg.cn/img_convert/1c815c8c9786f52999f972beb09255f1.png)

- 下到的k8stomcatcluster20180201.tar是個壓縮包，複製到可以執行kubectl命令的ubuntu電腦上，然後解壓開，是個名為k8stomcatcluster的資料夾；

### Spring boot的web工程原始碼下載

- GitHub下載，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| 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，如下圖紅框所示：

![這裡寫圖片描述](https://img-blog.csdnimg.cn/img_convert/bd383f7322841ef1bdd22f1d74fec9e7.png)

- 接下來我們開始實戰開發吧；

### 開發環境
- 本次實戰開發環境的具體資訊如下： 
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工程，這裡我們還是重新建立一次；
- 建立一個springboot工程，pom.xml內容如下：

```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></relativepath> 
	</parent>

<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>

<plugin>
				<groupid>com.spotify</groupid>
				<artifactid>docker-maven-plugin</artifactid>
				<version>0.4.12</version>
				
				<configuration>
					
					<imagename>bolingcavalry/${project.artifactId}</imagename>
					
					<imagetags>
						<imagetag>${project.version}</imagetag>
					</imagetags>
					
					<baseimage>java:8u111-jdk</baseimage>
					
					<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映象；
- 整個工程只有一個Controller，開通一個http介面，將當前伺服器IP地址返回，原始碼如下：

```java
@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;
 }
}
```
- 以上就是工程的關鍵原始碼；
- 在pom.xml所在目錄執行mvn clean package -DskipTests docker:build，會編譯構建工程，並且在本地製作好映象檔案，如下：

```bash
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映象三部曲之二：編碼和構建映象》](https://bbs.huaweicloud.com/blogs/350907)

### 讓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，內容如下：

```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檔案來配置的，內容如下：

```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內容如下：

```properties
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檔案內容如下，每行都有註釋就不再多說了：

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

#基礎映象
FROM nginx:stable

#作者
MAINTAINER BolingCavalry <zq2599>

#定義工作目錄
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 .，就能構建映象檔案了，如下:

```shell
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>
 ---> 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，內容如下：

```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：

```yaml
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全部建立和啟動：
```bash
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全部清除掉：

```bash
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工程服務；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</zq2599></zq2599>

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

相關文章