飞道的博客

我把SpringBoot应用部署到了K8S上,怎么感觉用起来像Docker!

550人阅读  评论(0)

想要把一个复杂的微服务项目部署到K8S上去,首先我们得学会把单个SpringBoot应用部署上去。今天我们来讲下如何把SpringBoot应用部署到K8S上去,和使用Docker Compose部署非常类似,希望对大家有所帮助!

学前准备

学习本文需要有一些K8S基础,对K8S还不了解的朋友可以参考如下的文章。

推送镜像到Docker Hub

之前我们都是自建的镜像仓库,这次我们换种方式,把镜像上传到Docker Hub中去。

  • 首先我们得注册个Docker Hub的账号,Docker Hub地址:https://hub.docker.com/

  • 部署应用使用之前的mall-tiny-fabric项目,先修改pom.xml文件,主要是添加Docker Hub的认证信息和修改下镜像前缀,具体内容如下;


   
  1. <configuration>
  2.     <!-- Docker 远程管理地址-->
  3.     <dockerHost>http: //192.168.5.94:2375</dockerHost>
  4.     <!-- 添加认证信息-->
  5.     <authConfig>
  6.         <push>
  7.             <!--Docker Hub 用户名-->
  8.             <username>macrodocker</username>
  9.             <!--Docker Hub 密码-->
  10.             <password>xxx</password>
  11.         </push>
  12.     </authConfig>
  13.     <images>
  14.         <image>
  15.             <!--修改镜像前缀为Docker Hub 用户名-->
  16.             <name>macrodocker/${project.name}:${project.version}</name>
  17.         </image>
  18.      </images>
  19.  </configuration>
  • 修改完成后使用package命令先把镜像打包到Linux服务器,再使用docker:push命令把镜像推送到Docker Hub中去:

  • 推送成功以后就可以在Docker Hub中看到镜像了。

应用部署

接下来我们将把应用部署到K8S上去,包含SpringBoot应用的部署和MySQL的部署。

部署MySQL

  • 首先添加配置文件mysql-deployment.yaml用于创建Deployment,具体说明参考注释即可;


   
  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   # 指定Deployment的名称
  5.   name: mysql-deployment
  6.   # 指定Deployment的标签 
  7.   labels:
  8.     app: mysql
  9. spec:
  10.   # 指定创建的Pod副本数量 
  11.   replicas:  1
  12.   # 定义如何查找要管理的Pod
  13.   selector:
  14.     # 管理标签app为mysql的Pod
  15.     matchLabels:
  16.       app: mysql
  17.   # 指定创建Pod的模板
  18.   template:
  19.     metadata:
  20.       # 给Pod打上app:mysql标签
  21.       labels:
  22.         app: mysql
  23.     # Pod的模板规约
  24.     spec:
  25.       containers:
  26.         - name: mysql
  27.           # 指定容器镜像
  28.           image: mysql: 5.7
  29.           # 指定开放的端口
  30.           ports:
  31.             - containerPort:  3306
  32.           # 设置环境变量
  33.           env:
  34.             - name: MYSQL_ROOT_PASSWORD
  35.               value: root
  36.           # 使用存储卷
  37.           volumeMounts:
  38.             # 将存储卷挂载到容器内部路径
  39.             - mountPath: / var/log/mysql
  40.               name: log-volume
  41.             - mountPath: / var/lib/mysql
  42.               name: data-volume
  43.             - mountPath: /etc/mysql
  44.               name: conf-volume
  45.       # 定义存储卷
  46.       volumes:
  47.         - name: log-volume
  48.           # hostPath类型存储卷在宿主机上的路径
  49.           hostPath:
  50.             path: /home/docker/mydata/mysql/log
  51.             # 当目录不存在时创建
  52.              type: DirectoryOrCreate
  53.         - name: data-volume
  54.           hostPath:
  55.             path: /home/docker/mydata/mysql/data
  56.              type: DirectoryOrCreate
  57.         - name: conf-volume
  58.           hostPath:
  59.             path: /home/docker/mydata/mysql/conf
  60.              type: DirectoryOrCreate
  • 通过应用配置文件来创建Deployment;

kubectl apply -f mysql-deployment.yaml
  • 运行成功后查询Deployment,发现mysql-deployment已经就绪;


   
  1. [macro@linux-local k8s]$ kubectl get deployments
  2. NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
  3. mysql-deployment           1/ 1      1             1            38s
  4. nginx-volume-deployment    2/ 2      2             2            6d5h
  • 想要其他Pod可以通过服务名称访问MySQL,需要创建Service,添加配置文件mysql-service.yaml用于创建Service;


   
  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   # 定义服务名称,其他Pod可以通过服务名称作为域名进行访问
  5.   name: mysql-service
  6. spec:
  7.   # 指定服务类型,通过Node上的静态端口暴露服务
  8.    type: NodePort
  9.   # 管理标签app为mysql的Pod
  10.   selector:
  11.     app: mysql
  12.   ports:
  13.     - name: http
  14.       protocol: TCP
  15.       port:  3306
  16.       targetPort:  3306
  17.       # Node上的静态端口
  18.       nodePort:  30306
  • 通过应用配置文件来创建Service;

kubectl apply -f mysql-service.yaml 
  • 运行成功后查询Service,发现mysql-service已经暴露在Node的30306端口上了;


   
  1. [macro@linux-local k8s]$ kubectl get services
  2. NAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
  3. kubernetes      ClusterIP    10.96 .0 .1        <none>         443/TCP           7d23h
  4. mysql-service   NodePort     10.107 .189 .51    <none>         3306: 30306/TCP    7s
  5. nginx-service   NodePort     10.101 .171 .181   <none>         80: 30080/TCP      6d2h
  • 部署完成后需要新建mall数据库,并导入相关表,表地址:https://github.com/macrozheng/mall-learning/blob/master/document/sql/mall.sql

  • 这里有个比较简单的方法来导入数据库,通过Navicat创建连接,先配置一个SSH通道;

  • 之后我们就可以像在Linux服务器上访问数据库一样访问Minikube中的数据库了,直接添加Minikube中数据库IP和端口即可。

部署SpringBoot应用

  • 首先添加配置文件mall-tiny-fabric-deployment.yaml用于创建Deployment,这里我们可以通过环境变量来覆盖SpringBoot中的默认配置;


   
  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: mall-tiny-fabric-deployment
  5.   labels:
  6.     app: mall-tiny-fabric
  7. spec:
  8.   replicas:  1
  9.   selector:
  10.     matchLabels:
  11.       app: mall-tiny-fabric
  12.   template:
  13.     metadata:
  14.       labels:
  15.         app: mall-tiny-fabric
  16.     spec:
  17.       containers:
  18.         - name: mall-tiny-fabric
  19.           # 指定Docker Hub中的镜像地址
  20.           image: macrodocker/mall-tiny-fabric: 0.0 .1-SNAPSHOT
  21.           ports:
  22.             - containerPort:  8080
  23.           env:
  24.             # 指定数据库连接地址
  25.             - name: spring.datasource.url
  26.               value: jdbc:mysql: //mysql-service:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
  27.             # 指定日志文件路径
  28.             - name: logging.path
  29.               value: / var/logs
  30.           volumeMounts:
  31.             - mountPath: / var/logs
  32.               name: log-volume
  33.       volumes:
  34.         - name: log-volume
  35.           hostPath:
  36.             path: /home/docker/mydata/app/mall-tiny-fabric/logs
  37.              type: DirectoryOrCreate
  • 通过应用配置文件来创建Deployment;

kubectl apply -f mall-tiny-fabric-deployment.yaml
  • 我们可以通过kubectl logs命令来查看应用的启动日志;


   
  1. [macro@linux-local k8s]$ kubectl get pods
  2. NAME                                           READY   STATUS    RESTARTS   AGE
  3. mall-tiny-fabric-deployment -8684857dff-pnz2t    1/ 1     Running    0           47s
  4. mysql-deployment -5dccc96ccf-sfxvg               1/ 1     Running    0           25m
  5. nginx-volume-deployment -6f6c89976d-nv2rn        1/ 1     Running    4           6d6h
  6. nginx-volume-deployment -6f6c89976d-tmhc5        1/ 1     Running    4           6d5h
  7. [macro@linux-local k8s]$ kubectl logs -f mall-tiny-fabric-deployment -8684857dff-pnz2t
  • 如果想要从外部访问SpringBoot应用,需要创建Service,添加配置文件mall-tiny-fabric-service.yaml用于创建Service;


   
  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   name: mall-tiny-fabric-service
  5. spec:
  6.    type: NodePort
  7.   selector:
  8.     app: mall-tiny-fabric
  9.   ports:
  10.     - name: http
  11.       protocol: TCP
  12.       port:  8080
  13.       targetPort:  8080
  14.       # Node上的静态端口
  15.       nodePort:  30180
  • 通过应用配置文件来创建Service;

kubectl apply -f mall-tiny-fabric-service.yaml
  • 此时服务已经暴露到了Node的30180端口上了;


   
  1. [macro@linux-local k8s]$ kubectl get services
  2. NAME                       TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
  3. kubernetes                 ClusterIP    10.96 .0 .1        <none>         443/TCP           7d23h
  4. mall-tiny-fabric-service   NodePort     10.100 .112 .84    <none>         8080: 30180/TCP    5s
  5. mysql-service              NodePort     10.107 .189 .51    <none>         3306: 30306/TCP    13m
  6. nginx-service              NodePort     10.101 .171 .181   <none>         80: 30080/TCP      6d2h
  • 在Linux服务器上,我们可以通过curl命令来访问下项目的Swagger页面,不过只能查看到返回的一串HTML代码。

curl $(minikube ip):30180/swagger-ui.html

外部访问应用

由于使用Minikube安装的K8S Node处于Linux服务器的内网环境,无法直接从外部访问,所以我们需要安装一个Nginx反向代理下才能访问。

  • 首先我们需要安装Nginx,对Nginx不熟悉的朋友直接参考该文章即可:《Nginx的这些妙用,你肯定有不知道的!》

  • 安装完成后添加一个Nginx的配置文件,这里我的配置路径为/mydata/nginx/conf/conf.d/,用于将mall-tiny.macrozheng.com域名的访问代理到K8S中的SpringBoot应用中去,proxy_pass为上面curl使用的路径;


   
  1. server {
  2.     listen        80;
  3.     server_name  mall-tiny.macrozheng.com; #修改域名
  4.     location / {
  5.         proxy_set_header Host $host:$server_port;
  6.         proxy_pass   http: //192.168.49.2:30180; #修改为代理服务地址
  7.         index  index.html index.htm;
  8.     }
  9.     error_page    500  502  503  504  / 50x.html;
  10.     location = / 50x.html {
  11.         root   /usr/share/nginx/html;
  12.     }
  13. }
  • 重启Nginx服务,再修改访问Linux服务器的本机host文件,添加如下记录;

192.168.5.94 mall-tiny.macrozheng.com
  • 之后即可直接在本机上访问K8S上的SpringBoot应用了,访问地址:http://mall-tiny.macrozheng.com/swagger-ui.html

总结

通过把SpringBoot应用部署到K8S上的一顿操作,我们可以发现在K8S上部署和在Docker上部署有很多相似之处。K8S上很多部署用的脚本,直接翻译之前使用Docker Compose的脚本即可,非常类似。如果你之前用过Docker,那么你就可以轻松上手K8S!

项目源码地址

https://github.com/macrozheng/mall-learning/tree/master/mall-tiny-fabric

推荐阅读


欢迎关注,点个在看


转载:https://blog.csdn.net/zhenghongcs/article/details/113361866
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场