Konfigurasi trigger API Gateway untuk mengeksekusi fungsi - Function Compute

Function Compute mendukung API Gateway sebagai sumber peristiwa. Anda dapat menentukan Function Compute sebagai layanan backend untuk API. Jika Anda menetapkan Function Compute sebagai layanan backend permintaan, API Gateway memicu fungsi terkait yang kemudian dijalankan sekali. Function Compute mengembalikan hasil eksekusi ke API Gateway. Topik ini menjelaskan cara mengonfigurasi API Gateway untuk memicu eksekusi fungsi di konsol Function Compute, termasuk konfigurasi parameter input, penulisan kode fungsi, dan pengujian fungsi.

Prasyarat

Function Compute
- Buat layanan
- Fungsi telah dibuat.
API Gateway
- Operasi API dengan Function Compute sebagai layanan backend telah dibuat

Langkah 1: Konfigurasikan parameter input fungsi

Saat API Gateway memicu fungsi, informasi dari API Gateway dikirim ke fungsi sebagai parameter input dalam bentuk event. Anda dapat menggunakan informasi event dari API Gateway untuk menguji apakah kode fungsi Anda benar.

Di halaman detail fungsi, klik tab Code dan klik ikon . Dari daftar drop-down yang muncul, pilih Configure Test Parameters.
Di panel Configure Test Parameters, klik tab Create New Test Event atau Modify Existing Test Event, lalu tentukan Event Name dan isi event. Setelah menentukan parameter, klik OK.
Contoh kode event:
```
{
    "path":"jalur permintaan api",
    "httpMethod":"nama metode permintaan",
    "headers":{semua header, termasuk header sistem},
    "queryParameters":{parameter query},
    "pathParameters":{parameter jalur},
    "body":"string payload permintaan",
    "isBase64Encoded":"true|false, menunjukkan apakah body di-enkode Base64"
}  
```
Catatan
- Jika nilai dari isBase64Encoded adalah true, konten body yang dikirim oleh API Gateway ke Function Compute di-enkode Base64. Function Compute mendekode konten body dari format Base64 sebelum diproses.
- Jika nilai dari isBase64Encoded adalah false, API Gateway tidak melakukan enkode Base64 pada konten body. Function Compute dapat langsung memperoleh konten body.

Langkah 2: Tulis kode fungsi dan uji fungsi

Masuk ke konsol Function Compute.
Di panel navigasi sisi kiri, klik Services & Functions.
Di bilah navigasi atas, pilih wilayah.
Di halaman Services, temukan layanan yang diinginkan dan klik Functions di kolom Actions.
Di halaman Functions, klik fungsi yang ingin Anda kelola.

Di halaman detail fungsi, klik tab Code, edit kode fungsi di editor kode, lalu klik Deploy.

Berikut ini adalah contoh kode dalam berbagai bahasa:

Node.js

module.exports.handler = function(event, context, callback) { 
   var event = JSON.parse(event);
   var content = {
     path: event.path,
     method: event.method,
     headers: event.headers,
     queryParameters: event.queryParameters,
     pathParameters: event.pathParameters,
     body: event.body
   // Anda bisa menulis logika Anda sendiri di sini.   
   }
   var response = {
        isBase64Encoded: false,
        statusCode: '200',
        headers: {
          'x-custom-header': 'nilai header'
        },
        body: content
      }; 
   callback(null, response)
};

Python

# -*- coding: utf-8 -*-
import json

def handler(event, context):
    event = json.loads(event)
    content = {
        'path': event['path'],
        'method': event['httpMethod'],
        'headers': event['headers'],
        'queryParameters': event['queryParameters'],
        'pathParameters': event['pathParameters'],
        'body': event['body']
    }
    # Anda bisa menulis logika Anda sendiri di sini.  
    rep = {
        "isBase64Encoded": "false",
        "statusCode": "200",
        "headers": {
            "x-custom-header": "tidak"
        },
        "body": content
    }
    return json.dumps(rep)

PHP

<?php
function handler($event, $context) {
    $event   = json_decode($event, $assoc = true);
    $content = [
        'path'            => $event['path'],
        'method'          => $event['httpMethod'],
        'headers'         => $event['headers'],
        'queryParameters' => $event['queryParameters'],
        'pathParameters'  => $event['pathParameters'],
        'body'            => $event['body'],
    ];

    $rep = [
        "isBase64Encoded" => "false",
        "statusCode"      => "200",
        "headers"         => [
            "x-custom-header" => "tidak",
        ],
        "body"            => $content,
    ];

    return json_encode($rep);
}

Java

Saat memprogram dalam Java, Anda harus mengimplementasikan kelas yang menggunakan metode handler yang telah ditentukan sebelumnya untuk Function Compute. Dua metode handler yang telah ditentukan sebelumnya tersedia. Untuk informasi lebih lanjut tentang lingkungan runtime Java dari Function Compute, lihat Kompilasi dan Penyebaran Paket Kode.

(Direkomendasikan) Gunakan handler PojoRequestHandler<I, O>.

import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.PojoRequestHandler;
import java.util.HashMap;
import java.util.Map;

public class ApiTriggerDemo implements PojoRequestHandler<ApiRequest, ApiResponse> {

    public ApiResponse handleRequest(ApiRequest request, Context context) {
        // Dapatkan informasi permintaan API. 
        context.getLogger().info(request.toString());
        String path = request.getPath();
        String httpMethod = request.getHttpMethod();
        String body = request.getBody();
        context.getLogger().info("path:" + path);
        context.getLogger().info("httpMethod:" + httpMethod);
        context.getLogger().info("body:" + body);

        // Anda bisa menulis logika Anda sendiri di sini. 

        // Contoh respons API. 
        Map headers = new HashMap();
        boolean isBase64Encoded = false;
        int statusCode = 200;
        String returnBody = "";
        return new ApiResponse(headers,isBase64Encoded,statusCode,returnBody);
    }
}

Berikut ini adalah definisi dua kelas POJO: ApiRequest dan ApiResponse.

Catatan Metode set() dan get() dari kelas POJO harus ditentukan.

import java.util.Map;

public class ApiRequest {
    private String path;
    private String httpMethod;
    private Map headers;
    private Map queryParameters;
    private Map pathParameters;
    private String body;
    private boolean isBase64Encoded;

    @Override
    public String toString() {
        return "Request{" +
                "path='" + path + '\'' +
                ", httpMethod='" + httpMethod + '\'' +
                ", headers=" + headers +
                ", queryParameters=" + queryParameters +
                ", pathParameters=" + pathParameters +
                ", body='" + body + '\'' +
                ", isBase64Encoded=" + isBase64Encoded +
                '}';
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public String getHttpMethod() {
        return httpMethod;
    }

    public void setHttpMethod(String httpMethod) {
        this.httpMethod = httpMethod;
    }

    public Map getHeaders() {
        return headers;
    }

    public void setHeaders(Map headers) {
        this.headers = headers;
    }

    public Map getQueryParameters() {
        return queryParameters;
    }

    public void setQueryParameters(Map queryParameters) {
        this.queryParameters = queryParameters;
    }

    public Map getPathParameters() {
        return pathParameters;
    }

    public void setPathParameters(Map pathParameters) {
        this.pathParameters = pathParameters;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public boolean getIsBase64Encoded() {
        return this.isBase64Encoded;
    }

    public void setIsBase64Encoded(boolean base64Encoded) {
        this.isBase64Encoded = base64Encoded;
    }
}

import java.util.Map;

public class ApiResponse {
    private Map headers;
    private boolean isBase64Encoded;
    private int statusCode;
    private String body;

    public ApiResponse(Map headers, boolean isBase64Encoded, int statusCode, String body) {
        this.headers = headers;
        this.isBase64Encoded = isBase64Encoded;
        this.statusCode = statusCode;
        this.body = body;
    }

    public Map getHeaders() {
        return headers;
    }

    public void setHeaders(Map headers) {
        this.headers = headers;
    }

    public boolean getIsBase64Encoded() {
        return isBase64Encoded;
    }

    public void setIsBase64Encoded(boolean base64Encoded) {
        this.isBase64Encoded = base64Encoded;
    }

    public int getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }
}

Berikut ini adalah contoh file pom.xml.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>apiTrigger</groupId>
    <artifactId>apiTrigger</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>com.aliyun.fc.runtime</groupId>
            <artifactId>fc-java-core</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>   
</project>

Gunakan handler StreamRequestHandler.

Untuk menggunakan handler ini, Anda harus mengonversi InputStream ke kelas POJO. Contoh kode berikut menjelaskan cara menggunakan handler ini.

File pom.xml harus dikonfigurasi dengan cara yang sama seperti handler PojoRequestHandler<I, O>.

import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.StreamRequestHandler;
import com.aliyun.fc.runtime.Context;
import com.google.gson.Gson;
import java.io.*;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

public class ApiTriggerDemo2 implements StreamRequestHandler {

    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) {
        try {
            // Konversi InputStream menjadi string. 
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuffer stringBuffer = new StringBuffer();
            String string = "";
            while ((string = bufferedReader.readLine()) != null) {
                stringBuffer.append(string);
            }
            String input = stringBuffer.toString();
            context.getLogger().info("inputStream: " + input);
            Request req = new Gson().fromJson(input, Request.class);
            context.getLogger().info("input req: ");
            context.getLogger().info(req.toString());
            String bodyReq = req.getBody();
            Base64.Decoder decoder = Base64.getDecoder();
            context.getLogger().info("body: " + new String(decoder.decode(bodyReq)));

            // Anda bisa memodifikasi logika Anda sendiri di sini. 

            // Parameter respons 
            Map headers = new HashMap();
            headers.put("x-custom-header", " ");
            boolean isBase64Encoded = false;
            int statusCode = 200;
            Map body = new HashMap();
            Response resp = new Response(headers, isBase64Encoded, statusCode, body);
            String respJson = new Gson().toJson(resp);
            context.getLogger().info("outputStream: " + respJson);
            outputStream.write(respJson.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    class Request {
        private String path;
        private String httpMethod;
        private Map headers;
        private Map queryParameters;
        private Map pathParameters;
        private String body;
        private boolean isBase64Encoded;

        @Override
        public String toString() {
            return "Request{" +
                    "path='" + path + '\'' +
                    ", httpMethod='" + httpMethod + '\'' +
                    ", headers=" + headers +
                    ", queryParameters=" + queryParameters +
                    ", pathParameters=" + pathParameters +
                    ", body='" + body + '\'' +
                    ", isBase64Encoded=" + isBase64Encoded +
                    '}';
        }

        public String getBody() {
            return body;
        }
    }

    // Function Compute mengembalikan respons ke API Gateway dalam format JSON berikut. 
    class Response {
        private Map headers;
        private boolean isBase64Encoded;
        private int statusCode;
        private Map body;

        public Response(Map headers, boolean isBase64Encoded, int statusCode, Map body) {
            this.headers = headers;
            this.isBase64Encoded = isBase64Encoded;
            this.statusCode = statusCode;
            this.body = body;
        }
    }
}

Klik tab Code dan klik Test Function.

Langkah 3: Verifikasi hasil

Setelah fungsi dieksekusi, Anda dapat melihat hasilnya di tab Code.

Function Compute mengirimkan hasil eksekusi ke API Gateway untuk diuraikan dalam format JSON berikut. Kode berikut menunjukkan contoh respons:

{
    "isBase64Encoded":true|false,
    "statusCode":httpStatusCode,
    "headers":{header respons},
    "body":"..."
}

Catatan

Jika hasil yang dikembalikan oleh Function Compute ke API Gateway tidak memenuhi persyaratan format, API Gateway mengembalikan kesalahan 503 Service Unavailable.
Jika konten parameter body dalam format biner, Anda harus meng-enkode konten dalam Base64. Untuk meng-enkode konten dalam Base64, Anda harus menyetel isBase64Encoded ke true. Jika konten parameter body tidak dalam format biner, Anda tidak perlu meng-enkode konten dalam Base64. Dalam hal ini, Anda harus menyetel isBase64Encoded ke false.

Pertanyaan Umum

Kode kesalahan 503 dikembalikan saat eksekusi fungsi dipicu oleh API Gateway tetapi log fungsi menunjukkan bahwa fungsi telah dieksekusi. Bagaimana cara menyelesaikan masalah ini?

API Gateway memerlukan Function Compute untuk mengembalikan respons dalam format tertentu. Jika hasil yang dikembalikan tidak dalam format yang diharapkan, API Gateway menganggap layanan backend tidak tersedia. Untuk informasi lebih lanjut tentang persyaratan format koneksi antara API Gateway dan Function Compute, lihat Format Event untuk Pemicu yang Berbeda dan Format Respons Function Compute.

Bagaimana cara menyetel tipe konten dari respons yang dikembalikan?

Sebagaimana ditunjukkan pada gambar, Anda dapat menentukan tipe konten respons saat menyetel operasi API. Untuk informasi lebih lanjut, lihat Buat Operasi API dengan Function Compute sebagai Layanan Backend. content-type

Kode kesalahan 503 dikembalikan saat saya menggunakan API Gateway untuk memanggil fungsi yang sebelumnya dipanggil tetapi belum dipanggil selama beberapa waktu. Bagaimana cara menyelesaikan masalah ini?

Jika suatu fungsi belum dipanggil selama beberapa waktu, lingkungan eksekusi baru harus disiapkan saat fungsi dipanggil lagi dan penundaan cold start terjadi. Dengan cara ini, timeout terjadi di API Gateway sebelum pemanggilan selesai. API Gateway menganggap layanan backend tidak tersedia. Untuk menyelesaikan masalah ini, atur periode timeout API Gateway ke nilai yang lebih besar.

Mengapa parameter body dari permintaan yang dilewatkan dari API Gateway ke Function Compute di-enkode Base64?

Parameter body dari permintaan di-enkode Base64 untuk mencegah kesalahan transmisi konten atau loss. Body dalam format form yang ditransmisikan oleh API Gateway tidak di-enkode Base64. Anda harus memilih Pemetaan Parameter Input di API Gateway saat mentransmisikan body dalam format form. Kami merekomendasikan Anda memeriksa apakah nilai dari isBase64 dalam event adalah true sebelum mendekode event di fungsi. Jika isBase64 disetel ke true, Anda harus mendekode body permintaan. Untuk informasi lebih lanjut tentang format event yang dilewatkan ke Function Compute oleh API Gateway, lihat Format Event untuk Pemicu yang Berbeda.

Informasi tambahan

Selain konsol Function Compute, Anda dapat mengonfigurasi pemicu menggunakan metode berikut:

Gunakan Serverless Devs untuk mengonfigurasi pemicu. Untuk informasi lebih lanjut, lihat Serverless Devs.
Gunakan SDK untuk mengonfigurasi pemicu. Untuk informasi lebih lanjut, lihat SDK.

Untuk memodifikasi atau menghapus pemicu yang telah dibuat, lihat Kelola Pemicu.