All Products
Search
Document Center

Platform For AI:Panggil layanan inferensi PAI-EAS melalui gRPC

Last Updated:May 15, 2026

PAI-EAS mendukung inferensi model berkinerja tinggi menggunakan protokol gRPC. Dibandingkan dengan HTTP/JSON, gRPC menawarkan serialisasi yang lebih efisien dan dukungan streaming yang lebih baik, sehingga sangat cocok untuk beban kerja yang sensitif terhadap latensi atau skenario yang memerlukan inferensi berbasis streaming.

Prasyarat

Sebelum memulai, pastikan Anda memenuhi persyaratan berikut:

  1. Anda telah menerapkan layanan inferensi PAI-EAS.

  2. Anda telah mengonfigurasi lingkungan pengembangan Go (disarankan Go 1.18 atau versi lebih baru).

  3. Anda telah menginstal paket dependensi gRPC yang diperlukan.

Poin-poin penting

Format titik akhir

Untuk memanggil layanan melalui gerbang, peroleh alamat layanan dari Konsol, ekstrak nama domain, lalu tambahkan nomor port :80. Untuk informasi selengkapnya, lihat Peroleh titik akhir akses dan token.

Penting

Port tetap diatur ke 80 karena PAI-EAS mengekspos layanan gRPC melalui gerbang yang mendengarkan pada port 80.

Tabel berikut menyediakan contoh titik akhir.

Metode akses

Titik akhir konsol

Titik akhir gRPC (tambahkan :80)

Jaringan publik

http://grpc-test.123456***.cn-hangzhou.pai-eas.aliyuncs.com/

grpc-test.123456***.cn-hangzhou.pai-eas.aliyuncs.com:80

VPC

http://grpc-test.123456***.vpc.cn-hangzhou.pai-eas.aliyuncs.com/

grpc-test.123456***.vpc.cn-hangzhou.pai-eas.aliyuncs.com:80

Catatan: Titik akhir gRPC tidak menyertakan awalan http://.

Otentikasi token

Untuk memanggil layanan inferensi gRPC PAI-EAS, Anda harus meneruskan token otentikasi dalam metadata permintaan. PAI-EAS menggunakan otentikasi Bearer Token. Saat melakukan panggilan gRPC, atur bidang authorization dalam metadata sebagai berikut:

authorization: Bearer <Token>

Token harus diawali dengan Bearer diikuti oleh spasi. Anda dapat memperoleh token tersebut dari halaman detail layanan di Konsol PAI-EAS.

Contoh kode

Sebelum menulis kode, siapkan file proto untuk layanan Anda dan kompilasi stub klien.

Contoh berikut menunjukkan alur kerja inti untuk memanggil layanan inferensi PAI-EAS melalui gRPC. Untuk file proto dan kode server yang sesuai, lihat Demo layanan gRPC.

package main

import (
	"context"
	"log"
	"time"

	pb "your-project/proto"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/metadata"
)

func main() {
	// Ganti dengan titik akhir gRPC Anda. Anda dapat menemukannya di panel info panggilan di Konsol PAI-EAS.
	// Format titik akhir jaringan publik adalah: service-name.{uid}.{region}.pai-eas.aliyuncs.com:80 (port tetap di 80).
	host := "your-service-endpoint:your port"
	// Ganti dengan token layanan Anda. Anda dapat menemukannya di halaman detail layanan di Konsol PAI-EAS.
	token := "your-service-token"

	log.Printf("Menghubungkan ke layanan gRPC PAI-EAS (%s)...", host)
        
        // 1. Membuat koneksi. Koneksi bersifat thread-safe. Kami menyarankan membuat satu koneksi dan menggunakannya kembali.
	conn, err := grpc.NewClient(
		host,
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		log.Fatalf("Gagal terhubung: %v", err)
	}
	defer conn.Close()

	// 2. Membuat klien.
	client := pb.NewGreeterServiceClient(conn)
	
	// 3. Menyisipkan token otentikasi menggunakan metadata gRPC.
	md := metadata.Pairs("authorization", "Bearer " + token)

	ctx := metadata.NewOutgoingContext(context.Background(), md)

	// 4. Mengatur timeout.
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	// 5. Membuat permintaan.
	req := &pb.HelloRequest{Name: "World"}

	// 6. Melakukan panggilan.
	resp, err := client.SayHello(ctx, req)
	if err != nil {
		log.Fatalf("Panggilan gagal: %v", err)
	}

	log.Printf("Menerima tanggapan: %s", resp.Message)
}
import grpc
import helloworld_pb2
import helloworld_pb2_grpc

# Ganti dengan titik akhir gRPC Anda. Anda dapat menemukannya di panel info panggilan di Konsol PAI-EAS.
# Format titik akhir jaringan publik adalah: service-name.{uid}.{region}.pai-eas.aliyuncs.com:80 (port tetap di 80).
host = "your-service-endpoint:your port"
# Ganti dengan token layanan Anda. Anda dapat menemukannya di halaman detail layanan di Konsol PAI-EAS.
token = "your-service-token"

# 1. Membuat saluran untuk terhubung ke server.
channel = grpc.insecure_channel(host)

# 2. Menginisialisasi stub (handle klien).
stub = helloworld_pb2_grpc.GreeterServiceStub(channel)

# 3. Membuat permintaan.
request = helloworld_pb2.HelloRequest(name="World")

# 4. Membuat metadata otentikasi untuk meneruskan token ke layanan PAI-EAS.
metadata = (("authorization",  "Bearer " + token),)

print("Memulai panggilan gRPC...")

try:
    # 5. Melakukan permintaan sinkron. Teruskan metadata untuk otentikasi.
    response = stub.SayHello(request, metadata=metadata, timeout=5.0)
    print(response.message)
except grpc.RpcError as e:
    print(f"Panggilan gagal: {e.code()} - {e.details()}")
finally:
    channel.close()

Praktik terbaik

  • Penggunaan kembali koneksi: Koneksi gRPC bersifat thread-safe. Kami menyarankan membuat koneksi saat aplikasi dimulai dan menggunakannya kembali untuk semua permintaan berikutnya.

    Penting

    Koneksi idle dapat diputus oleh perangkat jaringan perantara. Di lingkungan produksi, Anda harus mengaktifkan heartbeat keepalive. Gunakan KeepaliveParams di Go dan parameter options di Python. Praktik ini menjaga koneksi tetap aktif dan memungkinkan koneksi ulang otomatis tanpa gangguan.

  • Timeout: Atur timeout yang sesuai untuk setiap panggilan gRPC guna mencegah permintaan hang tanpa batas akibat masalah jaringan atau layanan.

FAQ

Otentikasi gagal (UNAUTHENTICATED)

Periksa apakah token Anda benar dan belum kedaluwarsa. Juga, pastikan penulisan nama bidang authorization dalam metadata sudah benar. Token harus diawali dengan Bearer diikuti oleh spasi.

Koneksi timeout (UNAVAILABLE)

Verifikasi bahwa titik akhir gRPC benar dan jaringan dapat dijangkau.

Saat menggunakan titik akhir VPC, pastikan klien dan layanan PAI-EAS berada dalam VPC dan wilayah yang sama. Selain itu, periksa apakah aturan security group Anda mengizinkan traffic pada port yang relevan.

Lampiran

Demo layanan gRPC

Definisi API

  1. Di direktori root proyek Anda, buat file bernama helloworld.proto untuk mendefinisikan layanan GreeterService yang mencakup metode SayHello.

    • Permintaan: HelloRequest, yang berisi bidang string bernama name.

    • Tanggapan: HelloResponse, yang berisi bidang string bernama message.

    Klik untuk melihat helloworld.proto

    syntax = "proto3";
    
    package helloworld;
    
    option go_package = "your-project/proto;helloworld";
    
    message HelloRequest {
      string name = 1;
    }
    
    message HelloResponse {
      string message = 1;
    }
    
    service GreeterService {
      rpc SayHello (HelloRequest) returns (HelloResponse);
    }
  2. Kompilasi file .proto untuk menghasilkan file kode helloworld_pb2_grpc.py dan helloworld_pb2.py. Perintah berikut menggunakan Python sebagai contoh.

    python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

2. Penerapan server

Terapkan layanan ke PAI-EAS. Struktur proyeknya sebagai berikut:

my-grpc-demo
├── helloworld_pb2_grpc.py
├── helloworld_pb2.py
└── server.py  

Klik untuk melihat server.py

import grpc
from concurrent import futures
import helloworld_pb2
import helloworld_pb2_grpc

# Implementasikan logika layanan.
class GreeterServicer(helloworld_pb2_grpc.GreeterServiceServicer):
    def SayHello(self, request, context):
        # Logika bisnis: Menggabungkan string.
        response_msg = f"Hello, {request.name}!"
        return helloworld_pb2.HelloResponse(message=response_msg)


def serve():
    # 1. Buat server dengan kolam thread.
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
  
    # 2. Daftarkan implementasi layanan ke server.
    helloworld_pb2_grpc.add_GreeterServiceServicer_to_server(GreeterServicer(), server)
   
    # 3. Dengarkan pada sebuah port. Ini adalah alamat penerapan.
    port = "[::]:50051"
    server.add_insecure_port(port)
   
    print(f"Server dimulai, mendengarkan pada {port} ...")
    server.start()
   
    # 4. Blokir thread utama agar layanan tetap berjalan.
    server.wait_for_termination()

if __name__ == "__main__":
    serve()

Klik untuk melihat konfigurasi JSON untuk layanan PAI-EAS

{
    "cloud": {
        "computing": {
            "instances": [
                {
                    "type": "ecs.c7.large"
                }
            ]
        }
    },
    "containers": [
        {
            "image": "eas-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai-eas/python-inference:py39-ubuntu2004",
            "port": 50051,
            "prepare": {
                "pythonRequirements": [
                    "grpcio",
                    "grpcio-tools"
                ]
            },
            "script": "python /mnt/data/server.py"
        }
    ],
    "metadata": {
        "cpu": 2,
        "disk": "30Gi",
        "enable_grpc": true,
        "instance": 1,
        "memory": 4000,
        "name": "grpc_test",
        "rpc": {
            "keepalive": 5000
        },
        "workspace_id": "your-workspace-id"
    },
    "storage": [
        {
            "mount_path": "/mnt/data/",
            "oss": {
                "path": "oss://my-oss/eas/my-grpc-demo/",
                "readOnly": false
            }
        }
    ]
}