使用minikube在k8s中部署golang镜像程序

k8s是一个容器编排平台，使用k8s可以实现对docker的自动化的管理和编排，还可以管理k8s的流量调度、可视化观测等功能

这边采用minikube在本地mac部署一个k8s集群，并且在集群中部署golang程序。
采用ingress进行流量管理，并且用service和deployment进行管理对应的pod

一、环境依赖

1、minikube
2、docker desktop
3、golang环境

二、代码结构

golang镜像采用Dockerfile进行构建，构建后的golang镜像采用yaml配置进行k8s集群部署，项目目录如下

image.png

main.go

应用主程序如下，采用8001端口进行运行

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "math/rand"
    "net/http"
)

var (
    WebRequestTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "web_reqeust_total",
        Help: "Number of hello requests in total",
    }, []string{"method", "path", "code"})
    /*WebRequestDurationHistogram = prometheus.NewHistogramVec(prometheus.HistogramOpts{
        Name:    "http_request_duration_seconds",
        Help:    "Histogram of the duration of HTTP requests",
        Buckets: prometheus.DefBuckets,
    }, []string{"method", "path"})*/
)

func init() {
    prometheus.MustRegister(WebRequestTotal)
    //prometheus.MustRegister(WebRequestDurationHistogram)
}
func main() {
    r := gin.Default() //创建gin

    r.Use(func(c *gin.Context) {
        //start := time.Now()
        //处理请求
        c.Next()
        //duration := time.Since(start).Seconds()
        //记录请求

        //WebRequestDurationHistogram.WithLabelValues(c.Request.Method, c.Request.URL.Path).Observe(duration)
    })
    r.GET("/", index) //绑定路由
    r.GET("/metrics", gin.WrapH(promhttp.Handler()))
    // 定义一个健康检查的路由
    r.GET("/health", func(c *gin.Context) {
        b := rand.Intn(100)
        label := make(prometheus.Labels, 0)
        if b <= 50 {

            label["code"] = "12"
            label["method"] = c.Request.Method
            label["path"] = c.Request.URL.Path
            WebRequestTotal.With(label).Inc()
        } else {
            label["code"] = "0"
            label["method"] = c.Request.Method
            label["path"] = c.Request.URL.Path
            WebRequestTotal.With(label).Inc()
        }
        //WebRequestTotal.WithLabelValues(c.Request.Method, c.Request.URL.Path).Inc()
        c.String(http.StatusOK, "OK")
    })
    r.POST("/update", func(c *gin.Context) {
        c.String(http.StatusOK, "OK")
    })
    r.Run(":8001") //运行绑定端口
}

func index(c *gin.Context) {
    fmt.Println("1111")
    c.JSON(200, gin.H{
        "message": "go!go!gono!yesyes",
    })
}

Dockerfile

# 使用官方 Go 镜像作为构建环境
FROM golang:1.20 AS builder

COPY ./ /go/src
WORKDIR /go/src

# 下载 Go 依赖并编译应用
#RUN go build -o myapp
RUN CGO_ENABLED=0 go build  -o myapp main.go
# 使用更小的镜像来运行应用
#FROM alpine:latest

# 复制编译好的二进制文件到新镜像
#COPY --from=builder /app/myapp /usr/local/bin/myapp

# 设置容器入口点
#ENTRYPOINT ["/usr/local/bin/myapp"]

COPY ./entrypoint.sh /sbin/entrypoint.sh
RUN chmod +x /sbin/entrypoint.sh

#声明容器将使用的网络端口 8080 和 8001。这不会实际暴露端口，但会告诉 Docker 运行时，这些端口需要暴露给外部服务
EXPOSE 8080 8001
ENTRYPOINT ["/sbin/entrypoint.sh"]

entrypoint.sh

#!/bin/bash
/go/src/myapp

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp-container
          image: myapp:v1.0
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 8001

service.yaml

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 8001
      targetPort: 8001
      nodePort: 31997   #  NodePort 端口
  type: NodePort

ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - host: myapp.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myapp-service
                port:
                  number: 8001

三、运行minikube

minikube start #启动minikube
minikube dashboard --ur #打开minikube管理面板

四、切换docker环境

当启动docker desktop后，默认的docker环境是docker desktop中的，需要运行如下命令

eval $(minikube docker-env)

会修改当前 shell 环境中的 Docker 配置，使其指向 Minikube 内部的 Docker 守护进程，后续的任何 Docker 命令（如 docker build、docker run 等）都将在 Minikube 的虚拟机中运行。

五、构建镜像

docker build -t myapp:v1.0 .

六、启动ingress

运行如下命令

minikube addons enable ingress

ingress资源可以来处理外部请求的流量，定义外部流量如何路由到service中，如上方的ingress.yaml定义了流量路由到myapp-service中的8001端口中

七、部署deployment

kubectl apply -f deployment.yaml

—replicas：设置了pod的副本为1个（也就是设置运行的pod为一个）
—image：采用myapp:v1.0镜像进行pod的部署
—containerPort：容器暴露的端口,容器监听在8001端口
—matchLabels
app：myapp 选择所有带有 app: myapp 标签的 Pods
—labels
app：myapp :这个标签将被应用到 Pod 上，用于匹配上面的 selector。

八、部署service

kubectl apply -f service.yaml

这个用于外部流量进行路由到内部的pod中
—selector
app：myapp 选择标签为 app=myapp 的 Pod，即 Service 会将流量路由到拥有这个标签的 Pod 上。
—port: 8001：这是 Service 暴露的端口。外部请求通过这个端口访问服务。
—targetPort: 8001：服务将流量转发到容器内部的端口 8001。

九、部署ingress

kubectl apply -f ingress.yaml

—host：myapp.local #定义了主机主机名（域名规则），如果访问的域名是myapp.local，此规则将会生效
—path:/ #指定了当请求路径以 / 开头时，如何处理流量。这个路径匹配规则可以将所有以 / 开头的路径转发到相应的后端服务
—pathType: Prefix：#路径类型为 Prefix，表示路径匹配的是前缀，即所有以 / 开头的路径都会匹配
—backend.service.name：myapp-service #当路径匹配时，应该把流量转发到servie名称为myapp-service中
—backend.service.port.number:8001 #流量转发到myapp-service中的8001端口中