Ce guide décrit les API du SDK officiel pour Go et fournit des exemples de code complets pour les formats d'entrée et de sortie courants.
Pour plus d'informations sur les cas d'utilisation du SDK et les principes d'appel, consultez la rubrique SDK d'appel de service.
Prérequis
Lorsque vous appelez un service d'inférence à l'aide du SDK pour Go, le gestionnaire de packages Go télécharge automatiquement le code source du SDK depuis GitHub lors de la compilation. Il n'est pas nécessaire d'installer le SDK au préalable. Si vous devez personnaliser la logique d'appel, téléchargez le code source du SDK pour Go et modifiez-le localement.
Pour importer le SDK, utilisez le code suivant :
import (
"github.com/pai-eas/eas-golang-sdk/eas"
)Démarrage rapide
Sélectionnez la classe Request correspondant au format des données d'entrée de votre modèle. L'exemple ci-dessous illustre un appel minimal de bout en bout utilisant une requête sous forme de chaîne de caractères.
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "my_service")
client.SetToken("YOUR_SERVICE_TOKEN")
client.Init()
resp, err := client.StringPredict("[{}]")
if err != nil {
fmt.Printf("failed to predict: %v\n", err.Error())
} else {
fmt.Printf("%v\n", resp)
}
}Référence de l'API
Le SDK pour Go met à disposition les classes suivantes, regroupées par fonctionnalité :
Groupe | Description |
Client principal | PredictClient : configure les informations relatives au service telles que l'endpoint, le nom du service et le token, envoie des requêtes et reçoit les réponses. |
Entrée et sortie |
|
Service de file d'attente |
|
PredictClient
Classe cliente principale utilisée pour configurer les informations du service, envoyer des requêtes et recevoir les résultats de prédiction.
Méthode | Description |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Initialise l'objet PredictClient. Après avoir défini les paramètres à l'aide des méthodes précédentes, vous devez appeler |
|
|
|
|
|
|
|
|
TFRequest
Construit les données d'entrée pour les modèles TensorFlow.
Méthode | Description |
|
|
|
|
|
|
TFResponse
Analyse les données de sortie des modèles TensorFlow.
Méthode | Description |
|
|
|
|
TorchRequest
Construit les données d'entrée pour les modèles PyTorch.
Méthode | Description |
| Crée un objet |
|
|
|
|
TorchResponse
Analyse les données de sortie des modèles PyTorch.
Méthode | Description |
|
|
|
|
QueueClient
Interagit avec le service de file d'attente EAS pour produire, consommer et gérer les données.
Méthode | Description |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
types.Watcher
Lit les données envoyées depuis le canal d'abonnement du service de file d'attente.
Méthode | Description |
|
|
| Ferme un objet watcher et sa connexion de données backend. Remarque Un client ne peut avoir qu'un seul objet watcher actif à la fois. Vous devez fermer l'objet watcher actuel avant d'en créer un nouveau. |
Exemples
Inférence synchrone par format
Choisissez l'exemple de code en fonction des types d'entrée et de sortie de votre service.
String
Si vous déployez un service avec un processeur personnalisé, vous l'appelez généralement à l'aide de chaînes, par exemple lors de l'appel d'un service de modèle PMML. Le programme suivant présente un exemple complet.
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "scorecard_pmml_example")
client.SetToken("YWFlMDYyZDNmNTc3M2I3MzMwYmY0MmYwM2Y2MTYxMTY4NzBkNzdj****")
client.Init()
req := "[{\"fea1\": 1, \"fea2\": 2}]"
for i := 0; i < 100; i++ {
resp, err := client.StringPredict(req)
if err != nil {
fmt.Printf("failed to predict: %v\n", err.Error())
} else {
fmt.Printf("%v\n", resp)
}
}
}TensorFlow
Pour les modèles TensorFlow, utilisez respectivement TFRequest et TFResponse comme formats de données d'entrée et de sortie. Le programme suivant présente un exemple complet.
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "mnist_saved_model_example")
client.SetToken("YTg2ZjE0ZjM4ZmE3OTc0NzYxZDMyNmYzMTJjZTQ1YmU0N2FjMTAy****")
client.Init()
tfreq := eas.TFRequest{}
tfreq.SetSignatureName("predict_images")
tfreq.AddFeedFloat32("images", []int64{1, 784}, make([]float32, 784))
for i := 0; i < 100; i++ {
resp, err := client.TFPredict(tfreq)
if err != nil {
fmt.Printf("failed to predict: %v", err)
} else {
fmt.Printf("%v\n", resp)
}
}
}PyTorch
Pour les modèles PyTorch, utilisez respectivement TorchRequest et TorchResponse comme formats de données d'entrée et de sortie. Le programme suivant présente un exemple complet.
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "pytorch_resnet_example")
client.SetTimeout(500)
client.SetToken("ZjdjZDg1NWVlMWI2NTU5YzJiMmY5ZmE5OTBmYzZkMjI0YjlmYWVl****")
client.Init()
req := eas.TorchRequest{}
req.AddFeedFloat32(0, []int64{1, 3, 224, 224}, make([]float32, 150528))
req.AddFetch(0)
for i := 0; i < 10; i++ {
resp, err := client.TorchPredict(req)
if err != nil {
fmt.Printf("failed to predict: %v", err)
} else {
fmt.Println(resp.GetTensorShape(0), resp.GetFloatVal(0))
}
}
}Connexion directe VPC
Une connexion directe VPC vous permet d'accéder aux services déployés dans un groupe de ressources dédié Elastic Algorithm Service (EAS). Vous devez également connecter le groupe de ressources au vSwitch spécifié avant de pouvoir utiliser ce mode. Pour savoir comment acheter un groupe de ressources dédié EAS et configurer la connectivité réseau, consultez les rubriques Utiliser les groupes de ressources EAS et Configurer EAS pour accéder aux ressources publiques ou internes. Cette méthode diffère d'un appel standard car elle nécessite seulement une ligne de code supplémentaire : client.SetEndpointType(eas.EndpointTypeDirect). Ce mode est idéal pour les services à fort trafic et à haute concurrence. Voici un exemple de code :
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
// Format of a VPC direct connection endpoint: {uid}.vpc.{region-id}.pai-eas.aliyuncs.com. You can find the endpoint on the Invocation Information tab of the service details page in the EAS console.
client := eas.NewPredictClient("182848887922****.vpc.cn-shanghai.pai-eas.aliyuncs.com", "scorecard_pmml_example")
client.SetToken("YWFlMDYyZDNmNTc3M2I3MzMwYmY0MmYwM2Y2MTYxMTY4NzBkNzdj****")
client.SetEndpointType(eas.EndpointTypeDirect)
client.Init()
req := "[{\"fea1\": 1, \"fea2\": 2}]"
for i := 0; i < 100; i++ {
resp, err := client.StringPredict(req)
if err != nil {
fmt.Printf("failed to predict: %v\n", err.Error())
} else {
fmt.Printf("%v\n", resp)
}
}
}Paramètres de connexion client
Vous pouvez définir les paramètres de connexion du client à l'aide de la propriété http.Transport. L'exemple suivant montre comment configurer ces paramètres :
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
"net/http"
"time"
)
func main() {
// Format of a VPC direct connection endpoint: {uid}.vpc.{region-id}.pai-eas.aliyuncs.com. You can find the endpoint on the Invocation Information tab of the service details page in the EAS console.
client := eas.NewPredictClient("182848887922****.vpc.cn-shanghai.pai-eas.aliyuncs.com", "network_test")
client.SetToken("MDAwZDQ3NjE3OThhOTI4ODFmMjJiYzE0MDk1NWRkOGI1MmVhMGI0****")
client.SetEndpointType(eas.EndpointTypeDirect)
client.SetHttpTransport(&http.Transport{
MaxConnsPerHost: 300,
TLSHandshakeTimeout: 100 * time.Millisecond,
ResponseHeaderTimeout: 200 * time.Millisecond,
ExpectContinueTimeout: 200 * time.Millisecond,
})
}Service de file d'attente
Vous pouvez utiliser QueueClient pour envoyer des données à un service de file d'attente, interroger des données, consulter l'état du service de file d'attente et vous abonner aux envois de données depuis ce service. Dans cet exemple, une goroutine envoie des données au service de file d'attente, tandis qu'une autre utilise un watcher pour s'abonner et recevoir ces données.
Lorsque vous déployez un service d'inférence asynchrone dans EAS, une file d'attente d'entrée et une file d'attente de sortie sont générées automatiquement. Les adresses suivent généralement les formats ci-dessous :
File d'attente d'entrée : <domain>/api/predict/<service_name>
File d'attente de sortie : <domain>/api/predict/<service_name>/sink
Utilisez <service_name> ou <service_name>/sink pour créer le QueueClient selon vos besoins.
const (
QueueEndpoint = "182848887922****.cn-shanghai.pai-eas.aliyuncs.com"
// For example, if the EAS service name is test_qservice, the input queue name is test_qservice, and the output queue name is test_qservice/sink.
QueueName = "test_qservice"
QueueToken = "YmE3NDkyMzdiMzNmMGM3ZmE4ZmNjZDk0M2NiMDA3OTZmNzc1MTUx****"
)
queue, err := NewQueueClient(QueueEndpoint, QueueName, QueueToken)
// truncate all messages in the queue
attrs, err := queue.Attributes()
if index, ok := attrs["stream.lastEntry"]; ok {
idx, _ := strconv.ParseUint(index, 10, 64)
queue.Truncate(context.Background(), idx+1)
}
ctx, cancel := context.WithCancel(context.Background())
// create a goroutine to send messages to the queue
go func() {
i := 0
for {
select {
case <-time.NewTicker(time.Microsecond * 1).C:
_, _, err := queue.Put(context.Background(), []byte(strconv.Itoa(i)), types.Tags{})
if err != nil {
fmt.Printf("Error occured, retry to handle it: %v\n", err)
}
i += 1
case <-ctx.Done():
break
}
}
}()
// create a watcher to watch the messages from the queue
watcher, err := queue.Watch(context.Background(), 0, 5, false, false)
if err != nil {
fmt.Printf("Failed to create a watcher to watch the queue: %v\n", err)
return
}
// read messages from the queue and commit manually
for i := 0; i < 100; i++ {
df := <-watcher.FrameChan()
err := queue.Commit(context.Background(), df.Index.Uint64())
if err != nil {
fmt.Printf("Failed to commit index: %v(%v)\n", df.Index, err)
}
}
// everything is done, close the watcher
watcher.Close()
cancel()Dépannage
Pour résoudre les problèmes courants lors de l'appel de services avec le SDK pour Go, y compris leurs causes et solutions, consultez la section « Troubleshoot invocation exceptions » de la rubrique SDK d'appel de service.
Pour obtenir la liste complète des codes d'état de service, des messages d'erreur et des actions recommandées, consultez la rubrique Annexe : Codes d'état de service et erreurs courantes.