解析Go在微服务、Docker容器化、gRPC通信、Serverless函数计算等场景的应用

// 技术栈：原生Go + net/http包
package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 注册路由处理函数
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "欢迎来到Go驱动的云服务！当前并发数：%d", 
            // 获取当前goroutine数量（近似反映并发量）
            runtime.NumGoroutine())
    })

    // 启动服务监听8080端口
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

// 技术栈：Go + gRPC + Protobuf
// 先定义proto文件（user.proto）
/*
syntax = "proto3";
package user;

service UserService {
    rpc GetUser(UserRequest) returns (UserResponse);
}

message UserRequest {
    string user_id = 1;
}

message UserResponse {
    string name = 1;
    string email = 2;
}
*/

// 服务端实现
package main

import (
    "context"
    "net"
    
    "google.golang.org/grpc"
    pb "path/to/protos"
)

type server struct {
    pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    // 模拟数据库查询
    return &pb.UserResponse{
        Name:  "张三",
        Email: "zhangsan@cloud.com",
    }, nil
}

func main() {
    lis, _ := net.Listen("tcp", ":50051")
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, &server{})
    s.Serve(lis)
}

# 使用多阶段构建优化镜像大小
# 阶段一：编译环境
FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY . .
RUN go mod download
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

# 阶段二：运行环境
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

// 技术栈：Go + AWS Lambda
package main

import (
    "context"
    "fmt"
    
    "github.com/aws/aws-lambda-go/lambda"
)

type Request struct {
    Name string `json:"name"`
}

type Response struct {
    Message string `json:"message"`
}

func HandleRequest(ctx context.Context, req Request) (Response, error) {
    return Response{
        Message: fmt.Sprintf("你好 %s，当前内存使用：%d MB", 
            req.Name, 
            getMemoryUsage()),
    }, nil
}

func getMemoryUsage() uint64 {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    return m.Alloc / 1024 / 1024
}

func main() {
    lambda.Start(HandleRequest)
}

// 技术栈：Go + pgx驱动
package main

import (
    "context"
    "fmt"
    "time"
    
    "github.com/jackc/pgx/v5/pgxpool"
)

func main() {
    // 配置连接池
    config, _ := pgxpool.ParseConfig("postgres://user:pass@localhost:5432/clouddb")
    config.MaxConns = 50
    config.MinConns = 10
    config.HealthCheckPeriod = 1 * time.Minute

    pool, _ := pgxpool.NewWithConfig(context.Background(), config)
    defer pool.Close()

    // 执行查询
    var version string
    err := pool.QueryRow(context.Background(), 
        "SELECT version()").Scan(&version)
    
    if err != nil {
        panic(err)
    }
    fmt.Println("PostgreSQL版本:", version)
}

// 使用sync.Pool重用对象
var bufferPool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 0, 4096))
    },
}

func ProcessRequest(data []byte) {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buf)
    buf.Reset()
    
    // 使用缓冲处理数据...
}

// 使用errgroup管理并发任务
func ProcessTasks(tasks []Task) error {
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, task := range tasks {
        task := task // 重要！创建局部变量副本
        g.Go(func() error {
            select {
            case <-ctx.Done():
                return ctx.Err() // 快速失败
            default:
                return task.Execute()
            }
        })
    }
    
    return g.Wait()
}