Function Compute：Penangan

Apa itu penangan?

Penangan suatu fungsi di Function Compute adalah metode yang digunakan untuk memproses permintaan dalam kode fungsi. Saat suatu fungsi dipanggil, Function Compute menggunakan penangan yang telah dikonfigurasi untuk memproses permintaan. Anda dapat mengonfigurasi penangan dengan menentukan parameter Handler di Konsol Function Compute.

Penangan fungsi Go di Function Compute dikompilasi menjadi file biner yang dapat dieksekusi. Anda hanya perlu menyetel penangan fungsi Anda di Function Compute ke nama file yang dapat dieksekusi.

Untuk informasi lebih lanjut tentang fungsi Function Compute dan operasi terkait, lihat Buat fungsi acara.

Konfigurasi penangan harus sesuai dengan spesifikasi konfigurasi Function Compute. Spesifikasi konfigurasi bervariasi berdasarkan jenis penangan.

Contoh:

Dalam kode Go, Anda perlu memperkenalkan pustaka SDK resmi aliyun/serverless/fc-runtime-go-sdk/fc dan mengimplementasikan fungsi handler dan main. Contoh kode berikut memberikan sebuah contoh:

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)
}

Nilai input event adalah string JSON yang berisi properti key. Contoh kode berikut memberikan sebuah contoh:

{
  "key": "value"
}

Deskripsi parameter:

• package main: paket main. Setiap aplikasi Go berisi paket utama.

• import: mengimpor dependensi Function Compute. Anda perlu mengimpor dependensi berikut:

  • github.com/aliyun/fc-runtime-go-sdk/fc: pustaka inti untuk Go di Function Compute.

  • context: objek konteks Go di Function Compute.

• func HandleRequest(ctx context.Context, event StructEvent) (string, error): penangan, yang harus berisi kode untuk dieksekusi. Item berikut menjelaskan parameter:

  • ctx context.Context: informasi konteks waktu proses untuk fungsi Function Compute Anda. Untuk informasi lebih lanjut, lihat Konteks.

  • event StructEvent: data yang akan diteruskan saat fungsi dipanggil. Beberapa tipe data didukung.

  • string, error: pesan balasan, yang berisi string dan pesan kesalahan. Untuk informasi lebih lanjut, lihat Penanganan kesalahan.

  • return fmt.Sprintf("Hi,%s !", event.Key), nil: mengembalikan informasi hello, yang berisi input event. Jika nil dikembalikan, tidak ada kesalahan yang terjadi.

• func main(): titik masuk untuk menjalankan kode fungsi Function Compute. Program Go harus berisi fungsi main. Kode fc.Start(HandleRequest) memungkinkan program Anda berjalan di Alibaba Cloud Function Compute.

Tanda tangan penangan peristiwa

Item berikut mencantumkan tanda tangan penangan peristiwa yang valid. Di antaranya, InputType dan OutputType kompatibel dengan pustaka standar encoding/json.

Function Compute mendeserialisasi input InputType menggunakan metode json.Unmarshal dan menserialisasi OutputType yang dikembalikan menggunakan metode json.Marshal. Untuk informasi lebih lanjut tentang cara mendeserialisasi data yang dikembalikan oleh fungsi, lihat JSON Unmarshal.

• 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)

Untuk informasi lebih lanjut tentang contoh kode untuk penangan lainnya, lihat contoh-contoh.

Konteks

Untuk informasi lebih lanjut tentang cara menggunakan konteks, lihat Konteks.

Gunakan pemicu HTTP untuk memanggil fungsi

Contoh kode

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)
}

Contoh di atas memperkenalkan struktur permintaan HTTPTriggerEvent dan struktur respons HTTPTriggerResponse dari pemicu HTTP dari SDK. Untuk informasi lebih lanjut tentang format payload permintaan dan payload respons pemicu HTTP, lihat Gunakan pemicu HTTP untuk memanggil fungsi.

Sebelum Anda mulai

Gunakan contoh di atas untuk membuat fungsi dalam runtime Go dan buat pemicu HTTP. Untuk informasi lebih lanjut, lihat Buat fungsi acara dan Konfigurasikan pemicu HTTP.

Prosedur

1. Masuk ke Konsol Function Compute. Di panel navigasi kiri, klik Functions.

2. Di bilah navigasi atas, pilih wilayah. Di halaman Functions, klik fungsi yang ingin Anda kelola.

3. Di halaman detail fungsi, klik tab Konfigurasi. Di panel navigasi kiri, klik Triggers. Di halaman Pemicu, peroleh titik akhir publik dari pemicu HTTP.

4. Jalankan perintah berikut untuk memanggil fungsi:

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

   Penting

   • Jika parameter Authentication Method dari pemicu HTTP disetel ke No Authentication, Anda dapat menggunakan Postman atau curl untuk memanggil fungsi. Untuk informasi lebih lanjut, lihat Prosedur.

   • Jika parameter Metode Otentikasi dari pemicu HTTP disetel ke Otentikasi Tanda Tangan atau Otentikasi JWT, Anda dapat menggunakan metode tanda tangan atau metode otentikasi JWT untuk memanggil fungsi. Untuk informasi lebih lanjut, lihat Otentikasi.

Kesalahan yang mungkin terjadi

Contoh kode ini dapat dipanggil menggunakan pemicu HTTP atau nama domain kustom. Jika Anda menggunakan operasi API tetapi parameter uji yang dikonfigurasi tidak sesuai dengan persyaratan format permintaan pemicu HTTP, kesalahan akan dilaporkan.

Sebagai contoh, pesan kesalahan berikut dikembalikan jika Anda memanggil fungsi dengan mengklik Test Function di Konsol Function Compute setelah Anda mengonfigurasi parameter permintaan sebagai "Hello, FC!".

{
    "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}"
}

Jika Anda ingin memperoleh payload peristiwa permintaan asli, Anda dapat menggunakan penangan seperti yang ditunjukkan dalam contoh berikut.

// GetRawRequestEvent: peroleh peristiwa permintaan mentah
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)
}