go语言网站开发教程

⚡ go语言网站开发教程入门指南

Go语言(又称Golang)自2009年开源以来,凭借其简洁语法、强大并发模型和卓越性能,在Web开发领域迅速崛起。Go语言由Google团队开发,设计初衷是解决大规模软件工程中的编译慢、开发效率低、部署复杂等问题。其语法借鉴了C语言的简洁性,同时融合了Python等语言的现代特性,形成了一套高效、可靠、易维护的开发范式。

在Web开发领域,Go语言展现出独特优势。首先,其编译型特性带来接近C/C++的执行效率;其次,轻量级goroutine协程模型使高并发处理变得异常简单;再次,标准库完善,内置HTTP服务器、JSON处理、模板引擎等核心组件,大幅减少第三方依赖;最后,二进制文件静态链接特性使部署极其便捷,无需安装运行时环境。

本教程以实战为导向,系统讲解Go语言Web开发全流程。从基础环境搭建到生产级应用部署,覆盖现代Web开发的各个关键环节。特别适合有一定编程基础、希望快速掌握现代Web开发技术的开发者。教程内容经过大量真实项目验证,强调工程化思维与最佳实践,避免陷入"玩具项目"陷阱。

学习本教程前,建议具备以下基础:

Go语言环境搭建采用标准流程。访问Go官网下载对应平台安装包,安装完成后执行go version验证版本。推荐使用VS Code配合Go插件进行开发,插件提供智能提示、代码格式化、调试支持等完整功能。项目结构遵循官方推荐布局,以main.go为入口,按功能模块组织目录结构,确保代码可维护性。

Go语言核心特性包括:

Go语言在Web开发中的典型应用场景包括:高并发API服务、微服务架构、云原生应用、实时数据处理系统等。国内外知名互联网公司如字节跳动、腾讯、阿里、百度、Docker、Kubernetes等均大量采用Go语言构建核心服务。Go语言特别适合构建需要处理海量并发请求的Web服务,其单机万级并发连接处理能力远超传统语言。

⚙️ 核心框架:gin与echo深度解析

Go语言Web开发生态中,gin与echo是两大主流框架。gin由thinkgo团队开发,以高性能与丰富中间件著称;echo由labstack团队开发,以极简设计与卓越性能见长。两者均基于net/http构建,但提供了更高级的抽象与便捷功能,大幅提高开发效率。

gin框架是Go语言Web开发的首选框架。其核心优势在于路由设计精妙、中间件系统灵活、文档详尽、社区活跃。gin采用Radix树算法实现路由匹配,时间复杂度为O(k),k为路径长度,确保高并发下路由查找效率。其Context对象封装了请求与响应处理,提供链式调用接口,代码简洁优雅。

gin核心组件包括:

gin中间件系统采用责任链模式实现。每个中间件为func(*Context)类型函数,通过c.Next()控制执行流程。典型中间件包括日志记录、身份验证、跨域处理、请求限流等。开发者可自定义中间件,灵活组合实现复杂业务逻辑。

以下为gin路由注册与中间件应用示例:

package main
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
func main() {
	r := gin.Default()
	// 全局中间件
	r.Use(LoggerToFile())
	// 路由分组
	api := r.Group("/api/v1")
	{
		api.GET("/users", ListUsers)
		api.POST("/users", CreateUser)
		api.GET("/users/:id", GetUser)
		api.PUT("/users/:id", UpdateUser)
		api.DELETE("/users/:id", DeleteUser)
	}
	// 启动服务
	r.Run(":8080")
}
// 自定义日志中间件
func LoggerToFile() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 请求前处理
		start := time.Now()
		c.Set("startTime", start)
		// 处理请求
		c.Next()
		// 请求后处理
		end := time.Now()
		latency := end.Sub(start)
		clientIP := c.ClientIP()
		method := c.Request.Method
		path := c.Request.URL.Path
		statusCode := c.Writer.Status()
		log.Printf("| %3d | %13v | %15s | %s %s |",
			statusCode, latency, clientIP, method, path)
	}
}

echo框架以极致性能与极简设计闻名。其路由匹配采用基于Trie树的高效算法,单核QPS可达10万+。echo设计哲学是"少即是多",核心API精炼,文档清晰,适合快速开发与高性能需求场景。

echo核心特性包括:

echo与gin性能对比显示,在简单路由处理场景下,echo略胜一筹;在复杂业务逻辑场景下,两者差异微乎其微。实际选择应基于团队熟悉度、生态完善度与项目需求综合考量。

以下为echo路由与中间件示例:

package main
import (
	"github.com/labstack/echo/v4"
	"net/http"
	"time"
)
func main() {
	e := echo.New()
	// 全局中间件
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	// 路由分组
	api := e.Group("/api/v1")
	api.Use(authMiddleware())
	// 路由定义
	api.GET("/users", listUsers)
	api.POST("/users", createUser)
	api.GET("/users/:id", getUser)
	api.PUT("/users/:id", updateUser)
	api.DELETE("/users/:id", deleteUser)
	// 启动服务
	e.Start(":8080")
}
// 自定义认证中间件
func authMiddleware() echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			token := c.Request().Header.Get("Authorization")
			if token == "" {
				return echo.NewHTTPError(http.StatusUnauthorized, "missing token")
			}
			// 验证token逻辑
			if !validateToken(token) {
				return echo.NewHTTPError(http.StatusForbidden, "invalid token")
			}
			return next(c)
		}
	}
}

gin与echo对比总结:

gin vs echo 核心对比

特性 gin echo
路由性能 优秀(Radix树) 卓越(Trie树)
中间件数量 丰富(官方+社区) 核心内置
文档质量 详尽(多语言) 精炼(英文为主)
学习曲线 平缓 陡峭
社区活跃度 极高 高
二进制体积 中等 较小
依赖数量 较多 极少

实际项目中,gin更适合需要丰富中间件与快速开发的团队;echo则适合追求极致性能与轻量级依赖的场景。两者均支持HTTP/2、WebSocket、Graceful Shutdown等现代特性,可根据项目需求灵活选择。

〔〕gorm数据库操作全解析

GORM是Go语言最流行的ORM框架,由Go语言官方团队开发并维护。其设计目标是"让数据库操作像原生SQL一样高效,同时保持ORM的便捷性"。GORM支持MySQL、PostgreSQL、SQLite、SQL Server等多种数据库,提供完整的CRUD操作、关联查询、事务处理、预加载等高级功能。

GORM核心特性包括:

GORM连接配置采用DSN(Data Source Name)格式,不同数据库配置略有差异。MySQL配置示例:

package db
import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)
var DB *gorm.DB
func InitDB() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal("failed to connect database:", err)
	}
	DB = db
}

模型定义遵循GORM约定,自动映射数据库表结构。以下为用户模型定义:

package model
import (
	"gorm.io/gorm"
)
type User struct {
	ID        uint      `gorm:"primaryKey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `gorm:"index"` // 软删除
	Username  string         `gorm:"uniqueIndex;size:50"`
	Email     string         `gorm:"size:100;uniqueIndex"`
	Password  string         `gorm:"size:100"`
	Avatar    string         `gorm:"size:255"`
	Role      string         `gorm:"size:20;default:'user'"`
	Posts     []Post         `gorm:"foreignKey:AuthorID"`
}
type Post struct {
	ID        uint      `gorm:"primaryKey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	Title     string    `gorm:"size:100;not null"`
	Content   string    `gorm:"type:text"`
	AuthorID  uint
	Author    User      `gorm:"foreignKey:AuthorID"`
	Tags      []Tag     `gorm:"many2many:post_tags;"`
}

GORM查询操作分为链式查询与原生SQL两种方式。链式查询适合常规条件查询,原生SQL适合复杂查询场景。以下为典型查询示例:

// 链式查询
var user User
DB.Where("username = ?", "john").First(&user)
// 原生SQL
var users []User
DB.Raw("SELECT * FROM users WHERE role = ? AND created_at > ?", "admin", "2023-01-01").Scan(&users)
// 关联预加载
var posts []Post
DB.Preload("Author").Preload("Tags").Find(&posts)
// 分页查询
var total int64
var articles []Article
DB.Model(&Article{}).Count(&total)
DB.Limit(10).Offset(20).Find(&articles)

GORM事务处理采用func闭包形式,确保事务原子性。以下为转账事务示例:

func Transfer(fromID, toID uint, amount float64) error {
	return DB.Transaction(func(tx *gorm.DB) error {
		// 检查余额
		var fromAccount Account
		if err := tx.Where("user_id = ?", fromID).First(&fromAccount).Error; err != nil {
			return err
		}
		if fromAccount.Balance < amount {
			return errors.New("insufficient balance")
		}
		// 扣款
		if err := tx.Model(&fromAccount).Update("balance", gorm.Expr("balance - ?", amount)).Error; err != nil {
			return err
		}
		// 加款
		if err := tx.Model(&Account{}).Where("user_id = ?", toID).Update("balance", gorm.Expr("balance + ?", amount)).Error; err != nil {
			return err
		}
		// 记录日志
		log := TransactionLog{
			FromID:   fromID,
			ToID:     toID,
			Amount:   amount,
			Status:   "success",
			CreatedAt: time.Now(),
		}
		if err := tx.Create(&log).Error; err != nil {
			return err
		}
		return nil
	})
}

GORM性能优化要点包括:

以下为连接池配置示例:

import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"time"
)
func InitDB() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal("failed to connect database:", err)
	}
	sqlDB, err := db.DB()
	if err != nil {
		log.Fatal("failed to get sql.DB:", err)
	}
	// 配置连接池
	sqlDB.SetMaxOpenConns(100)
	sqlDB.SetMaxIdleConns(10)
	sqlDB.SetConnMaxLifetime(time.Hour)
	sqlDB.Ping()
	DB = db
}

GORM在实际项目中需配合数据库设计最佳实践使用。例如:

〈〉RESTful API设计规范与实践

RESTful API设计是现代Web开发的核心环节。本节深入探讨RESTful设计原则、常见陷阱与最佳实践,结合Go语言特性提供可落地的解决方案。

RESTful设计核心原则:

以下为典型RESTful API设计示例:

// 用户资源
GET    /api/v1/users          // 获取用户列表
POST   /api/v1/users          // 创建新用户
GET    /api/v1/users/:id      // 获取单个用户
PUT    /api/v1/users/:id      // 更新用户信息
DELETE /api/v1/users/:id      // 删除用户
// 文章资源
GET    /api/v1/posts          // 获取文章列表
POST   /api/v1/posts          // 创建新文章
GET    /api/v1/posts/:id      // 获取单篇文章
PUT    /api/v1/posts/:id      // 更新文章
DELETE /api/v1/posts/:id      // 删除文章
// 关联操作
GET    /api/v1/users/:id/posts  // 获取用户所有文章

HTTP状态码规范:

以下为错误响应统一格式:

{
  "code": 400,
  "message": "invalid request parameters",
  "details": [
    {
      "field": "email",
      "error": "email format is invalid"
    },
    {
      "field": "password",
      "error": "password must be at least 8 characters"
    }
  ]
}

Go语言中,通过自定义错误处理中间件实现统一错误响应:

package middleware
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
type ErrorResponse struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Details []ErrorDetail `json:"details,omitempty"`
}
type ErrorDetail struct {
	Field   string `json:"field"`
	Error   string `json:"error"`
}
func ErrorResponseHandler(c *gin.Context, code int, message string, details ...ErrorDetail) {
	c.JSON(code, ErrorResponse{
		Code:    code,
		Message: message,
		Details: details,
	})
	c.Abort()
}

分页查询设计:

以下为偏移分页响应示例:

{
  "data": [
    {
      "id": 1,
      "title": "Go语言入门",
      "author": "john"
    }
  ],
  "meta": {
    "total": 100,
    "page": 1,
    "limit": 10,
    "has_next": true,
    "has_prev": false
  }
}

API版本管理:

推荐采用URL路径版本化,简单直观,便于调试与文档生成。

API文档自动化:

以下为Swagger注解示例:

// @Summary      获取用户列表
// @Description  分页获取用户列表
// @Tags         users
// @Accept       json
// @Produce      json
// @Param        page   query     int  false  "页码"
// @Param        limit  query     int  false  "每页数量"
// @Success      200  {object}  pagination.Response{data=[]model.User}
// @Router       /api/v1/users [get]
func ListUsers(c *gin.Context) {
	// 实现逻辑
}

API设计还需考虑:

字段过滤与部分响应实现示例:

// 支持fields参数过滤响应字段
fields := c.Query("fields")
if fields != "" {
	// 解析fields参数,构建投影查询
}

♀♂认证授权体系设计

认证与授权是Web应用安全的核心环节。本节系统讲解JWT认证、OAuth2授权、RBAC权限模型等关键技术,结合Go语言实现生产级安全方案。

JWT认证机制:

JWT结构由三部分组成:Header、Payload、Signature

Go语言JWT实现采用gin-jwt中间件:

import (
	"github.com/appleboy/gin-jwt/v2"
	"time"
)
var identityKey = "id"
type login struct {
	Username string `form:"username" json:"username" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}
func LoginHandler(c *gin.Context) {
	var l login
	if err := c.ShouldBind(&l); err != nil {
		middleware.ErrorResponseHandler(c, http.StatusBadRequest, "invalid request",
			middleware.ErrorDetail{Field: "body", Error: err.Error()})
		return
	}
	// 验证用户名密码
	user := authenticate(l.Username, l.Password)
	if user == nil {
		middleware.ErrorResponseHandler(c, http.StatusUnauthorized, "invalid credentials")
		return
	}
	// 生成JWT
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		identityKey: user.ID,
		"exp":       time.Now().Add(time.Hour * 24).Unix(),
	})
	tokenString, err := token.SignedString([]byte("your-secret-key"))
	if err != nil {
		middleware.ErrorResponseHandler(c, http.StatusInternalServerError, "token generation failed")
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"token": tokenString,
		"expires": time.Now().Add(time.Hour * 24).Unix(),
	})
}

JWT中间件实现:

authMiddleware := &jwt.GinJWTMiddleware{
	Realm:       "go-tutorial",
	Key:         []byte("your-secret-key"),
	Timeout:     time.Hour * 24,
	MaxRefresh:  time.Hour * 24,
	IdentityKey: identityKey,
	PayloadFunc: func(data interface{}) jwt.MapClaims {
		if v, ok := data.(*model.User); ok {
			return jwt.MapClaims{
				identityKey: v.ID,
			}
		}
		return jwt.MapClaims{}
	},
	IdentityHandler: func(c *gin.Context) interface{} {
		claims := jwt.ExtractClaims(c)
		return claims[identityKey]
	},
	Authenticator: func(c *gin.Context) (interface{}, error) {
		var loginVals login
		if err := c.ShouldBind(&loginVals); err != nil {
			return "", jwt.ErrMissingLoginValues
		}
		user := authenticate(loginVals.Username, loginVals.Password)
		if user != nil {
			return user, nil
		}
		return "", jwt.ErrFailedAuthentication
	},
	Authorizator: func(data interface{}, c *gin.Context) bool {
		if v, ok := data.(*model.User); ok && v.Role == "admin" {
			return true
		}
		return false
	},
	Unauthorized: func(c *gin.Context, code int, message string) {
		middleware.ErrorResponseHandler(c, code, message)
	},
	TokenLookup:   "header: Authorization: Bearer",
	TokenHeadName: "Bearer",
	TimeFunc:      time.Now,
}

OAuth2授权流程:

Go语言OAuth2实现采用golang.org/x/oauth2库:

import (
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/github"
)
var githubConfig = &oauth2.Config{
	RedirectURL:  "https://yourapp.com/callback",
	ClientID:     "your-client-id",
	ClientSecret: "your-client-secret",
	Scopes:       []string{"user:email"},
	Endpoint:     github.Endpoint,
}
func GitHubLogin(c *gin.Context) {
	url := githubConfig.AuthCodeURL("state-token")
	c.Redirect(http.StatusTemporaryRedirect, url)
}
func GitHubCallback(c *gin.Context) {
	code := c.Query("code")
	token, err := githubConfig.Exchange(c, code)
	if err != nil {
		middleware.ErrorResponseHandler(c, http.StatusInternalServerError, "token exchange failed")
		return
	}
	// 使用token获取用户信息
	client := githubConfig.Client(c, token)
	// ...
}

RBAC权限模型:

Go语言RBAC实现示例:

type Permission struct {
	ID        uint
	Name      string
	Resources []string
}
type Role struct {
	ID         uint
	Name       string
	Permissions []Permission
}
func CheckPermission(user *User, resource string, action string) bool {
	for _, role := range user.Roles {
		for _, perm := range role.Permissions {
			if contains(perm.Resources, resource) && perm.Name == action {
				return true
			}
		}
	}
	return false
}

权限控制中间件实现:

func RequirePermission(permissions ...string) gin.HandlerFunc {
	return func(c *gin.Context) {
		user := c.MustGet("user").(*model.User)
		if !hasPermission(user, permissions) {
			middleware.ErrorResponseHandler(c, http.StatusForbidden, "permission denied")
			return
		}
		c.Next()
	}
}
func hasPermission(user *model.User, requiredPerms []string) bool {
	for _, role := range user.Roles {
		for _, perm := range role.Permissions {
			for _, req := range requiredPerms {
				if perm.Name == req {
					return true
				}
			}
		}
	}
	return false
}

认证授权最佳实践:

↑↓高并发系统设计与优化

高并发系统设计是Web应用的终极挑战。本节深入探讨Go语言高并发编程模型、性能优化技巧与生产级部署方案。

Go并发模型核心:

以下为典型并发模式示例:

// 工作池模式
func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		log.Printf("worker %d processing job %d", id, j)
		results <- j * 2
	}
}
func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)
	// 启动3个worker
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}
	// 发送任务
	for j := 1; j <= 9; j++ {
		jobs <- j
	}
	close(jobs)
	// 收集结果
	for a := 1; a <= 9; a++ {
		<-results
	}
}

连接池设计:

协程池实现示例:

type WorkerPool struct {
	jobQueue   chan func()
	wg         sync.WaitGroup
	numWorkers int
}
func NewWorkerPool(numWorkers int, queueSize int) *WorkerPool {
	pool := &WorkerPool{
		jobQueue:   make(chan func(), queueSize),
		numWorkers: numWorkers,
	}
	for i := 0; i < numWorkers; i++ {
		go pool.worker()
	}
	return pool
}
func (p *WorkerPool) worker() {
	p.wg.Add(1)
	defer p.wg.Done()
	for job := range p.jobQueue {
		job()
	}
}
func (p *WorkerPool) Submit(job func()) {
	p.jobQueue <- job
}
func (p *WorkerPool) Wait() {
	close(p.jobQueue)
	p.wg.Wait()
}

缓存策略:

Redis集成示例:

import (
	"github.com/go-redis/redis/v8"
	"context"
)
var ctx = context.Background()
func InitRedis() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	// 测试连接
	_, err := rdb.Ping(ctx).Result()
	if err != nil {
		log.Fatal("redis connection failed:", err)
	}
}
func GetCachedData(key string) (string, error) {
	val, err := rdb.Get(ctx, key).Result()
	if err == redis.Nil {
		// 缓存未命中,从数据库获取
		data := fetchDataFromDB(key)
		// 写入缓存
		rdb.Set(ctx, key, data, 1*time.Hour)
		return data, nil
	} else if err != nil {
		return "", err
	}
	return val, nil
}

限流策略:

Go语言限流实现:

import (
	"golang.org/x/time/rate"
	"net/http"
)
var limiter = rate.NewLimiter(rate.Every(100*time.Millisecond), 1)
func RateLimitMiddleware(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !limiter.Allow() {
			http.Error(w, "too many requests", http.StatusTooManyRequests)
			return
		}
		next(w, r)
	}
}

服务降级:

超时控制实现:

func FetchWithTimeout(url string) ([]byte, error) {
	client := &http.Client{
		Timeout: 5 * time.Second,
	}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	return io.ReadAll(resp.Body)
}

性能监控:

PProf性能分析示例:

import _ "net/http/pprof"
func main() {
	r := gin.Default()
	r.GET("/debug/pprof/", gin.WrapH(http.DefaultServeMux))
	r.GET("/debug/pprof/cmdline", gin.WrapH(http.DefaultServeMux))
	r.GET("/debug/pprof/profile", gin.WrapH(http.DefaultServeMux))
	r.GET("/debug/pprof/symbol", gin.WrapH(http.DefaultServeMux))
	r.GET("/debug/pprof/trace", gin.WrapH(http.DefaultServeMux))
	r.Run(":8080")
}

生产级部署方案:

◣◢测试与部署全流程

高质量Web应用离不开完善的测试体系与自动化部署流程。本节系统讲解Go语言测试方法与CI/CD实践。

单元测试:

测试示例:

package service
import (
	"testing"
)
func TestUserService_CreateUser(t *testing.T) {
	svc := NewUserService()
	// 测试成功创建用户
	user, err := svc.CreateUser(&CreateUserRequest{
		Username: "testuser",
		Email:    "test@example.com",
		Password: "password123",
	})
	if err != nil {
		t.Errorf("expected no error, got %v", err)
	}
	if user.ID == 0 {
		t.Errorf("expected user ID > 0, got %d", user.ID)
	}
	// 测试重复用户名
	_, err = svc.CreateUser(&CreateUserRequest{
		Username: "testuser",
		Email:    "test2@example.com",
		Password: "password456",
	})
	if err == nil {
		t.Errorf("expected error for duplicate username")
	}
}

测试覆盖率统计:

go test -coverprofile=coverage.out
go tool cover -func=coverage.out
go tool cover -html=coverage.out

集成测试:

集成测试示例:

package integration
import (
	"testing"
	"net/http/httptest"
	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
)
func TestCreateUserAPI(t *testing.T) {
	gin.SetMode(gin.TestMode)
	r := SetupRouter()
	// 创建测试用户
	jsonStr := `{"username":"testuser","email":"test@example.com","password":"password123"}`
	req := httptest.NewRequest("POST", "/api/v1/users", strings.NewReader(jsonStr))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	assert.Equal(t, http.StatusCreated, w.Code)
}

端到端测试:

CI/CD流程:

GitLab CI配置示例:

stages:
  - build
  - test
  - deploy
build:
  stage: build
  script:
    - go build -o app .
    - docker build -t myapp:$CI_COMMIT_SHA .
    - docker push myapp:$CI_COMMIT_SHA
  only:
    - main
test:
  stage: test
  script:
    - go test -v ./...
    - go test -coverprofile=coverage.out ./...
  only:
    - main
deploy:
  stage: deploy
  script:
    - kubectl set image deployment/myapp myapp=myapp:$CI_COMMIT_SHA
  only:
    - main

日志管理:

结构化日志示例:

package logger
import (
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"os"
)
var Logger *zap.SugaredLogger
func InitLogger() {
	config := zap.Config{
		Level:            zap.NewAtomicLevelAt(zap.InfoLevel),
		Development:      false,
		Encoding:         "json",
		EncoderConfig:    zap.NewProductionEncoderConfig(),
		OutputPaths:      []string{"stdout"},
		ErrorOutputPaths: []string{"stderr"},
	}
	logger, _ := config.Build()
	Logger = logger.Sugar()
}

健康检查:

健康检查端点实现:

func HealthCheck(c *gin.Context) {
	status := map[string]string{"status": "healthy"}
	// 检查数据库
	if err := db.DB().Ping(); err != nil {
		status["database"] = "unavailable"
		status["status"] = "degraded"
	}
	// 检查Redis
	if _, err := redis.Ping(ctx).Result(); err != nil {
		status["redis"] = "unavailable"
		status["status"] = "degraded"
	}
	if status["status"] == "healthy" {
		c.JSON(http.StatusOK, status)
	} else {
		c.JSON(http.StatusServiceUnavailable, status)
	}
}

部署最佳实践: