All Products
Search
Document Center

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

Last Updated:Sep 11, 2026

PAI-EAS mendukung inferensi model melalui gRPC. Dibandingkan dengan HTTP/JSON, gRPC menawarkan serialisasi yang lebih efisien dan dukungan streaming yang lebih baik, sehingga ideal untuk beban kerja inferensi yang sensitif terhadap latensi atau berbasis streaming.

Prasyarat

Sebelum memulai:

  1. Anda telah menerapkan layanan inferensi PAI-EAS.

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

  3. Anda telah menginstal paket dependensi gRPC yang diperlukan.

Poin-poin penting

Format titik akhir

Untuk memanggil layanan melalui gerbang, ambil titik akhir dari Konsol PAI-EAS, ekstrak nama domain, lalu tambahkan Port :80 seperti dijelaskan dalam Dapatkan titik akhir akses dan token.

Penting

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

Contoh titik akhir:

Metode akses

Titik akhir Console

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

PAI-EAS menggunakan otentikasi Bearer Token. Sertakan token dalam metadata permintaan gRPC dengan mengatur bidang authorization sebagai berikut:

authorization: Bearer <Token>

Tambahkan awalan Bearer diikuti spasi sebelum token. Dapatkan token Anda 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 pemanggilan gRPC. File proto dan kode server yang sesuai tersedia di apendiks 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 pada 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. Bangun 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. Buat klien.
	client := pb.NewGreeterServiceClient(conn)
	
	// 3. Sisipkan token otentikasi menggunakan metadata gRPC.
	md := metadata.Pairs("authorization", "Bearer " + token)

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

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

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

	// 6. Lakukan pemanggilan.
	resp, err := client.SayHello(ctx, req)
	if err != nil {
		log.Fatalf("Pemanggilan 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 pada 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. Buat saluran untuk terhubung ke server.
channel = grpc.insecure_channel(host)

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

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

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

print("Memulai pemanggilan gRPC...")

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

Praktik terbaik

  • Penggunaan koneksi ulang: Koneksi gRPC bersifat thread-safe. Buat satu koneksi saat startup aplikasi dan gunakan kembali untuk semua permintaan.

    Penting

    Koneksi idle mungkin diputus oleh perangkat perantara. Di lingkungan produksi, aktifkan keepalive: gunakan KeepaliveParams di Go atau parameter options di Python.

  • Timeout: Tetapkan timeout untuk setiap pemanggilan guna mencegah permintaan hang akibat kegagalan jaringan atau layanan.

FAQ

Otentikasi gagal (UNAUTHENTICATED)

Verifikasi bahwa token Anda valid dan belum kedaluwarsa. Pastikan nama bidang metadata tepat authorization, dan nilainya diawali dengan Bearer diikuti spasi.

Koneksi timeout (UNAVAILABLE)

Verifikasi bahwa titik akhir gRPC benar dan jaringan dapat dijangkau.

Untuk titik akhir VPC, pastikan klien dan layanan PAI-EAS berada dalam VPC dan wilayah yang sama. Periksa apakah aturan security group mengizinkan traffic pada port yang relevan.

Apendiks

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: Gabungkan 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
            }
        }
    ]
}