使用GO和云功能构建无服务器API

要构建一个无服务器API，需先设置Go环境并安装Google Cloud SDK，然后编写一个HTTP函数处理请求，最后通过gcloud CLI部署到Cloud Functions。1. 安装Go 1.18+和Google Cloud SDK并配置项目；2. 创建Go模块并编写HTTP处理函数，支持GET和POST方法，处理JSON输入并返回响应；3. 简化代码仅保留Handler函数，移除本地服务器逻辑；4. 使用gcloud命令部署函数，指定运行时、入口点和触发方式；5. 测试API的GET和POST接口，验证返回结果；6. 生产环境中应添加CORS支持、输入验证、日志记录，并配置超时与内存限制；7. 可选使用本地服务器或模拟器测试函数。部署后即可通过HTTPS URL访问自动扩展的无服务器API，实现免运维的后端服务。

Building a serverless API with Go and Cloud Functions is a great way to run backend code without managing infrastructure. Google Cloud Functions (GCF) supports Go as a first-class language, making it straightforward to deploy lightweight, event-driven APIs that scale automatically. Here’s how to set one up effectively.

✅ Set Up Your Go Environment

Before writing any code, make sure your local development environment supports Go and the Google Cloud SDK.

1. Install Go (1.18+ recommended) from golang.org
2. Install Google Cloud SDK and authenticate:

   gcloud auth login
   gcloud config set project YOUR_PROJECT_ID

3. Initialize a Go module:

   mkdir my-api && cd my-api
   go mod init my-api

Go functions for GCF are just regular Go functions with a specific signature. You’ll use the cloud.google.com/go/functions/framework package when testing locally, but it's not required for deployment.

? Write a Simple HTTP Function

Create a file called function.go:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

// Person represents a simple data structure
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// Handler responds to HTTP requests
func Handler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        fmt.Fprint(w, "Hello from Go Cloud Function!")
    case "POST":
        var person Person
        if err := json.NewDecoder(r.Body).Decode(&person); err != nil {
            http.Error(w, "Invalid JSON", http.StatusBadRequest)
            return
        }
        response := map[string]string{
            "message": fmt.Sprintf("Hello %s, you're %d years old!", person.Name, person.Age),
        }
        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(response); err != nil {
            log.Printf("Error encoding response: %v", err)
        }
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

// Entry point for Cloud Functions
func main() {
    http.HandleFunc("/", Handler)
    // Use PORT environment variable, default to 8080
    port := "8080"
    if envPort := os.Getenv("PORT"); envPort != "" {
        port = envPort
    }
    log.Printf("Starting server on port %s", port)
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

? Note: The main() function is needed only if you're testing locally or using container-based deployment. For standard GCF, the function is invoked via the Handler entry point.

But for Cloud Functions, you don’t need the main() server loop — Google handles that. So simplify it:

// simplified_function.go
package p

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func Handler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        fmt.Fprint(w, "Hello from Go!")
    case "POST":
        var person Person
        if err := json.NewDecoder(r.Body).Decode(&person); err != nil {
            http.Error(w, "Bad Request", http.StatusBadRequest)
            return
        }
        response := map[string]string{
            "message": fmt.Sprintf("Hi %s, age %d!", person.Name, person.Age),
        }
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(response)
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

Save this as main.go. The entry point is Handler, which will be specified during deployment.

☁️ Deploy to Google Cloud Functions

Use the gcloud CLI to deploy:

gcloud functions deploy go-api-function \
  --runtime go119 \
  --entry-point Handler \
  --trigger-http \
  --allow-unauthenticated \
  --region us-central1

Replace go119 with the latest supported Go version (e.g., go121).

After deployment, you’ll get an HTTPS URL like:

https://us-central1-YOUR_PROJECT.cloudfunctions.net/go-api-function

Test it:

curl -X GET https://<your-function-url>

curl -X POST https://<your-function-url> \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","age":30}'

You should get a JSON response:

{"message":"Hi Alice, age 30!"}

?️ Tips for Production Use

While this setup works for simple cases, consider these points for real-world use:

• Use API Gateway or Cloud Endpoints: For better control over routing, auth, rate limiting.
• Add CORS support if serving from a frontend:

  w.Header().Set("Access-Control-Allow-Origin", "*")
  w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
  w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
  if r.Method == "OPTIONS" {
      return
  }

• Validate payloads and sanitize inputs.
• Enable Cloud Logging — use log.Printf(); logs appear in Cloud Logging.
• Set timeouts and memory limits during deployment:

  --timeout 60s --memory 256MB

? Test Locally with Emulator (Optional)

You can test locally using a simple Go server:

// main.go
package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", Handler)
    log.Println("Starting local server on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Then run:

go run main.go

And test with curl http://localhost:8080.

Building a serverless API in Go with Cloud Functions is fast and efficient for small to medium workloads. You get automatic scaling, pay-per-use pricing, and minimal ops overhead.

Basically: write a Go HTTP handler, deploy with gcloud, and you’re live.

以上是使用GO和云功能构建无服务器API的详细内容。更多信息请关注PHP中文网其他相关文章！