完整版jenkins （pipeline）+k8s实战之go项目

好的，下面我将为你提供一份完整版的 Jenkins Pipeline + Kubernetes 实战教程，用于构建和部署一个简单的 Go 项目。这个项目将使用 Jenkins Pipeline 插件和 Kubernetes 插件，自动化构建、测试和部署 Go 项目到 Kubernetes 集群中。

前置条件：

- 你已经安装了 Docker、Kubernetes 和 Jenkins，并且能够正常运行它们。
- 你已经安装了 Go 开发环境，并且熟悉 Go 项目的基本结构和命令。

步骤一：创建 Go 项目

首先，我们需要创建一个简单的 Go 项目，用于演示如何使用 Jenkins Pipeline 和 Kubernetes 构建和部署 Go 项目。假设我们的 Go 项目代码位于 /path/to/project 目录下，项目结构如下：

/path/to/project
├── Dockerfile
├── main.go
└── Makefile

其中，Dockerfile 文件用于构建 Docker 镜像，main.go 文件是 Go 项目的主要代码文件，Makefile 文件用于构建和测试 Go 项目。

下面是 Dockerfile 文件的内容：

FROM golang:1.16-alpine AS build
WORKDIR /app
COPY . .
RUN make build

FROM alpine:3.14
COPY --from=build /app/myapp /usr/bin/
CMD ["myapp"]

这个 Dockerfile 文件使用了官方的 Go 1.16 Alpine 镜像作为基础镜像，并将项目代码复制到容器的工作目录 /app 中。然后，它使用 Makefile 文件中的 build 命令编译 Go 项目，并将编译后的二进制文件 myapp 复制到 Alpine 镜像中。最后，它定义了一个容器启动命令 CMD ["myapp"]，用于启动 Go 项目。

下面是 main.go 文件的内容：

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

这个 main.go 文件非常简单，它只是输出了一个 "Hello, World!" 的字符串。

下面是 Makefile 文件的内容：

.PHONY: all build test clean
BINARY=myapp
VERSION=1.0.0

all: build test

build:
    go build -o $(BINARY) main.go

test:
    go test -v ./...

clean:
    rm -f $(BINARY)

这个 Makefile 文件定义了四个命令：build、test、clean 和 all。其中，build 命令用于编译 Go 项目，test 命令用于运行 Go 项目的测试用例，clean 命令用于清理编译后的二进制文件，all 命令用于同时执行 build 和 test 命令。

步骤二：创建 Kubernetes 集群

接下来，我们需要创建一个 Kubernetes 集群，用于部署 Go 项目。这个集群可以是本地的 Minikube 集群，也可以是云端的 Kubernetes 集群，具体操作方式可以参考 Kubernetes 官方文档。

假设我们已经创建了一个名为 mycluster 的 Kubernetes 集群，并且已经正确配置了 kubectl 命令行工具。我们可以使用 kubectl get nodes 命令来验证 Kubernetes 集群是否正常运行。

步骤三：创建 Jenkins Pipeline 项目

接下来，我们需要在 Jenkins 中创建一个 Pipeline 项目，用于构建和部署 Go 项目到 Kubernetes 集群中。

- 在 Jenkins 中，点击 "New Item" 按钮，选择 "Pipeline" 项目类型。
- 在 "General" 标签页中，填写项目名称和描述信息。
- 在 "Pipeline" 标签页中，选择 "Pipeline script from SCM"，并选择 Git 作为 SCM 类型。
- 在 "Repository URL" 中填写 Go 项目的 Git 仓库 URL，选择 "Credentials"，填写 Git 仓库的用户名和密码。
- 在 "Script Path" 中填写 Jenkinsfile，这个文件用于定义 Pipeline 脚本。

下面是 Jenkinsfile 文件的内容：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'make build'
                sh 'docker build --tag myapp:latest .'
            }
        }
        stage('Test') {
            steps {
                sh 'make test'
            }
        }
        stage('Deploy') {
            environment {
                KUBECONFIG = credentials('my-kubeconfig')
            }
            steps {
                sh 'kubectl apply --filename deployment.yaml'
            }
        }
    }
}

这个 Jenkinsfile 文件定义了三个阶段：Build、Test 和 Deploy。其中，Build 阶段用于编译 Go 项目，并构建 Docker 镜像；Test 阶段用于运行 Go 项目的测试用例；Deploy 阶段用于部署 Go 项目到 Kubernetes 集群中。

在 Deploy 阶段中，我们使用了 Kubernetes 插件提供的 credentials 函数，从 Jenkins 的凭据库中获取 Kubernetes 集群的配置信息，并将其赋值给 KUBECONFIG 环境变量。然后，我们使用 kubectl apply 命令将 deployment.yaml 文件中定义的 Kubernetes 资源部署到 Kubernetes 集群中。

步骤四：创建 Kubernetes 部署文件

最后，我们需要创建一个 deployment.yaml 文件，用于部署 Go 项目到 Kubernetes 集群中。假设我们的 Kubernetes 集群已经正确配置，deployment.yaml 文件如下：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 80

这个 deployment.yaml 文件定义了一个名为 myapp 的 Deployment，它包含了 3 个 Pod，每个 Pod 包含了一个名为 myapp 的容器。容器使用了之前构建的 myapp Docker 镜像，并将容器的 HTTP 端口映射到 80 端口。

步骤五：运行 Jenkins Pipeline 项目

现在，我们可以在 Jenkins 中运行这个 Pipeline 项目，它会自动化构建、测试和部署我们的 Go 项目到 Kubernetes 集群中。

在 Jenkins 项目页面中，点击 "Build Now" 按钮，Jenkins 将会自动触发一个构建过程，按照 Pipeline 脚本中定义的阶段和任务，自动化构建、测试和部署 Go 项目到 Kubernetes 集群中。

如果一切顺利，我们可以使用 kubectl get deployments 和 kubectl get pods 命令来验证 Go 项目是否已经成功部署到 Kubernetes 集群中。

希望这个教程能够帮助你理解如何使用 Jenkins Pipeline 和 Kubernetes 构建和部署 Go 项目。如果你有任何问题或需要进一步的帮助，请随时回复我。