Gunakan handler runtime Go untuk event dan trigger HTTP - Function Compute

Definisikan fungsi handler dalam Go, kompilasi menjadi binary executable, lalu atur parameter Handler di Konsol Function Compute ke nama binary tersebut. Function Compute menjalankan handler ini setiap kali fungsi Anda dipanggil.

Catatan

Jika Anda ingin menggunakan Pemicu HTTP atau nama domain kustom untuk mengakses fungsi, peroleh struct request sebelum menentukan respons HTTP. Untuk informasi lebih lanjut, lihat Gunakan Pemicu HTTP untuk memanggil fungsi.

Mulai cepat

Impor paket SDK github.com/aliyun/fc-runtime-go-sdk/fc, implementasikan fungsi handler, lalu berikan ke fc.Start dalam main().

package main

import (
    "fmt"
    "context"

    "github.com/aliyun/fc-runtime-go-sdk/fc"
)

type StructEvent struct {
    Key string `json:"key"`
}

func HandleRequest(ctx context.Context, event StructEvent) (string, error) {
    return fmt.Sprintf("hello, %s!", event.Key), nil
}

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

Handler ini menerima event JSON dengan bidang key dan mengembalikan string salam:

{
  "key": "value"
}

Penjelasan Kode

Elemen	Tujuan
`package main`	Paket entri wajib untuk setiap executable Go
`github.com/aliyun/fc-runtime-go-sdk/fc`	SDK Go Function Compute
`context`	Menyediakan konteks waktu proses untuk pemanggilan fungsi
`HandleRequest(ctx context.Context, event StructEvent) (string, error)`	Fungsi handler: menerima konteks dan event bertipe, mengembalikan string dan error
`fc.Start(HandleRequest)`	Mendaftarkan handler ke Function Compute dan memulai loop waktu proses

Untuk informasi lebih lanjut tentang objek context, lihat Context. Untuk penanganan error, lihat Penanganan Error.

Membangun dan Menerapkan

Inisialisasi modul Go dan instal SDK Function Compute:

go mod init my-fc-function
go get github.com/aliyun/fc-runtime-go-sdk

Kompilasi handler Anda menjadi binary Linux (Function Compute berjalan di lingkungan Linux):

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o main main.go

Atur parameter Handler di Konsol Function Compute ke main (nama binary yang dikompilasi). Untuk petunjuk membuat fungsi, lihat Buat Fungsi Event.

Signature handler

Handler harus mengikuti aturan berikut:

Harus berupa fungsi.
Menerima 0 hingga 2 parameter input. Jika menggunakan dua parameter, yang pertama harus berupa context.Context.
Mengembalikan 0 hingga 2 nilai. Nilai kembali tunggal harus bertipe error. Dua nilai kembali harus memiliki error sebagai nilai kedua.

Semua signature yang valid:

func ()
func () error
func (InputType) error
func () (OutputType, error)
func (InputType) (OutputType, error)
func (context.Context) error
func (context.Context, InputType) error
func (context.Context) (OutputType, error)
func (context.Context, InputType) (OutputType, error)

InputType dan OutputType harus kompatibel dengan pustaka standar encoding/json. Function Compute melakukan deserialisasi input dengan json.Unmarshal dan serialisasi output dengan json.Marshal. Untuk detailnya, lihat JSON Unmarshal.

Tipe event input

Parameter event mendukung beberapa tipe Go. Pilih tipe yang sesuai dengan kasus penggunaan Anda:

Jenis Peristiwa	Kasus penggunaan	Contoh
Struct	Event bertipe kuat dengan bidang yang diketahui	event-struct.go
`string`	Input string mentah	event-string.go
`map[string]interface{}`	Event dinamis atau longgar bertipe	event-map.go

Untuk contoh lainnya, lihat fc-runtime-go-sdk/examples.

Handler Pemicu HTTP

Untuk menangani permintaan HTTP melalui Pemicu HTTP atau nama domain kustom, gunakan struct HTTPTriggerEvent dan HTTPTriggerResponse dari paket SDK events.

Menangani event Pemicu HTTP

package main

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

	"github.com/aliyun/fc-runtime-go-sdk/events"
	"github.com/aliyun/fc-runtime-go-sdk/fc"
)

type HTTPTriggerEvent events.HTTPTriggerEvent
type HTTPTriggerResponse events.HTTPTriggerResponse

func (h HTTPTriggerEvent) String() string {
	jsonBytes, err := json.MarshalIndent(h, "", "  ")
	if err != nil {
		return ""
	}
	return string(jsonBytes)
}

func NewHTTPTriggerResponse(statusCode int) *HTTPTriggerResponse {
	return &HTTPTriggerResponse{StatusCode: statusCode}
}

func (h *HTTPTriggerResponse) String() string {
	jsonBytes, err := json.MarshalIndent(h, "", "  ")
	if err != nil {
		return ""
	}
	return string(jsonBytes)
}

func (h *HTTPTriggerResponse) WithStatusCode(statusCode int) *HTTPTriggerResponse {
	h.StatusCode = statusCode
	return h
}

func (h *HTTPTriggerResponse) WithHeaders(headers map[string]string) *HTTPTriggerResponse {
	h.Headers = headers
	return h
}

func (h *HTTPTriggerResponse) WithIsBase64Encoded(isBase64Encoded bool) *HTTPTriggerResponse {
	h.IsBase64Encoded = isBase64Encoded
	return h
}

func (h *HTTPTriggerResponse) WithBody(body string) *HTTPTriggerResponse {
	h.Body = body
	return h
}

func HandleRequest(event HTTPTriggerEvent) (*HTTPTriggerResponse, error) {
	fmt.Printf("event: %v\n", event)
	if event.Body == nil {
		return NewHTTPTriggerResponse(http.StatusBadRequest).
			WithBody(fmt.Sprintf("the request did not come from an HTTP Trigger, event: %v", event)), nil
	}

	reqBody := *event.Body
	if event.IsBase64Encoded != nil && *event.IsBase64Encoded {
		decodedByte, err := base64.StdEncoding.DecodeString(*event.Body)
		if err != nil {
			return NewHTTPTriggerResponse(http.StatusBadRequest).
				WithBody(fmt.Sprintf("HTTP Trigger body is not base64 encoded, err: %v", err)), nil
		}
		reqBody = string(decodedByte)
	}
	return NewHTTPTriggerResponse(http.StatusOK).WithBody(reqBody), nil
}

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

Handler ini membaca badan permintaan HTTP dari HTTPTriggerEvent, mendekode jika dienkripsi Base64, lalu mengembalikannya dalam tanggapan. Struct permintaan dan tanggapan berasal dari github.com/aliyun/fc-runtime-go-sdk/events. Untuk detail format muatan, lihat Gunakan Pemicu HTTP untuk Memanggil Fungsi.

Memanggil fungsi

Prasyarat

Sebelum memulai, pastikan Anda telah:

Membuat fungsi dalam waktu proses Go dengan kode handler di atas
Mengonfigurasi Pemicu HTTP untuk fungsi tersebut

Untuk petunjuk penyiapan, lihat Buat Fungsi Event dan Konfigurasi Pemicu HTTP.

Prosedur

Masuk ke Konsol Function Compute. Di panel navigasi kiri, klik Functions.
Di bilah navigasi atas, pilih wilayah. Di halaman Functions, klik fungsi yang ingin Anda kelola.
Klik tab Triggers. Salin Titik Akhir Publik dari Pemicu HTTP.

Kirim permintaan ke titik akhir tersebut:

   curl -i "https://http-trigger-demo.cn-shanghai.fcapp.run" -d "Hello FC!"

Penting

Jika Authentication Method Pemicu HTTP diatur ke No Authentication, panggil fungsi langsung dengan curl atau Postman.
Jika diatur ke Signature Authentication atau JWT Authentication, sertakan kredensial yang diperlukan. Untuk detailnya, lihat Autentikasi.

Memecahkan masalah error Test Function

Handler ini mengharapkan input dari Pemicu HTTP atau nama domain kustom. Memanggilnya melalui tombol Test Function di konsol mengirimkan muatan event standar, bukan muatan Pemicu HTTP. Hal ini menghasilkan error 400:

{
    "statusCode": 400,
    "body": "the request did not come from an HTTP Trigger, event: {\n  \"version\": null,\n  \"rawPath\": null,\n  \"headers\": null,\n  \"queryParameters\": null,\n  \"body\": null,\n  \"isBase64Encoded\": null,\n  \"requestContext\": null\n}"
}

Untuk memeriksa muatan event mentah apa pun sumbernya, gunakan handler []byte:

// GetRawRequestEvent mengembalikan event mentah sebagai badan respons
func GetRawRequestEvent(event []byte) (*HTTPTriggerResponse, error) {
	fmt.Printf("raw event: %s\n", string(event))
	return NewHTTPTriggerResponse(http.StatusOK).WithBody(string(event)), nil
}

func main() {
	fc.Start(GetRawRequestEvent)
}

Function Compute:Penanganan waktu proses Go