Est-il possible d'utiliser gRPC avec hyperledger-chaincode, et si oui, comment éviter les erreurs lors des appels sur le réseau de test ?

l'éditeur php Xigua est là pour répondre à vos questions. Oui, vous pouvez utiliser gRPC avec Hyperledger Chaincode. gRPC est un framework d'appel de procédure à distance (RPC) open source hautes performances qui permet à votre Chaincode de communiquer avec d'autres services. Pour éviter les erreurs lors des appels sur le réseau de test, vous pouvez suivre plusieurs étapes. Tout d’abord, assurez-vous que votre réseau de test est configuré et fonctionne correctement. Deuxièmement, vérifiez votre code et vos fichiers de configuration pour vous assurer que vous utilisez correctement gRPC. Enfin, assurez une gestion et une journalisation des erreurs appropriées afin que tous les problèmes soient découverts et résolus rapidement. Grâce à ces étapes, vous devriez pouvoir éviter les erreurs lors des appels sur votre réseau de test et communiquer en douceur à l'aide de gRPC.

Contenu de la question

Je souhaite utiliser grpc dans le code de chaîne Fabric pour réaliser une communication inter-chaînes au lieu d'utiliser le SDK Fabric. Mais lorsque j'appelle la fonction chaincode sur fabric-sample/test-network, j'obtiens toujours une erreur.

error: endorsement failure during invoke. response: status:500 message:"error in simulation: failed to execute transaction eb5e480bd4075a767f56ae263741ca0f5f19620ef88952e26b7f1952bdbe83cd: could not launch chaincode chaincode_1.2:d3f97f15a635e73d3de230c8e5899e5fb95a68cf897c03e19f9e4eeca7ca3fd5: chaincode registration failed: container exited with 2"

Quelqu'un peut-il me dire quelle est la cause de cette erreur ? Y a-t-il un bug dans mon code chaîne ou grpc ne peut pas être utilisé dans les fonctions de code chaîne ?

Mon code chaîne pour grpc :

func (s *smartcontract) begin(ctx contractapi.transactioncontextinterface) error {
    server.main()
    return nil
}

func (s *smartcontract) client(ctx contractapi.transactioncontextinterface) error {
    // client.clientfunc is the client main function
    client.clientfunc(xt, r, sign, m)
}

server.go

func main() {
    listen, err := net.listen("tcp", ":9090")
    if err != nil {
        fmt.printf("failed to listen: %v", err)
        return
    }
    grpcserver := grpc.newserver()
    pb.registersendserviceserver(grpcserver, &server{})
    err2 := grpcserver.serve(listen)
    if err2 != nil {
        fmt.printf("failed to serve: %v", err2)
        return
    }
}

client.go

func Clientfunc(Xt *btcec.PublicKey, R *btcec.PublicKey, s *big.Int, m []byte) []byte {
    conn, err := grpc.Dial("127.0.0.1:9090", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    client := pb.NewSendServiceClient(conn)
    output := &pb.SignInput{
        XtX: Xt.X().Int64(),
        XtY: Xt.Y().Int64(),
        M:   m,
        RX:  R.X().Int64(),
        RY:  R.Y().Int64(),
        S:   s.Int64(),
    }
    resp, _ := client.Send(context.Background(), output)
    return resp.GetM()
}

Solution

Qui peut me dire la cause de cette erreur ?

Voir hyperledger fabric v2.x/ Log Control pour plus de détails, qu'est-ce qui peut vous dire ce qui cause Erreur 500 (Erreur interne du serveur) est le journal du serveur

Selon la façon dont vous l'exécutez :

docker logs <chaincode_container_id>
kubectl logs -n <namespace> <pod_name>
oc logs -n <namespace> <pod_name>

Cela peut être dû à un problème dans votre code de chaîne (comme un bug dans votre code grpc), ou cela peut être dû à l'environnement dans lequel le code de chaîne s'exécute.

À partir de votre code, vous pourriez envisager de ne pas démarrer le serveur grpc en chaincode (server.main()). Chaincode s'exécute au sein d'un réseau de structure hyperledger et ne gère pas la communication réseau comme une application autonome.
Au lieu de cela, vous devez faire du serveur grpc un service distinct qui s'exécute de manière indépendante, et le code chaîne peut ensuite communiquer avec ce service selon vos besoins.

La fonction

plus client.clientfunc() semble établir la connexion grpc, envoyer la demande et attendre la réponse. Il s'agit d'une opération synchrone qui peut poser des problèmes si la réponse met beaucoup de temps à arriver. Il est préférable d'utiliser des opérations asynchrones (c'est-à-dire envoyer une requête et gérer la réponse dans une fonction de rappel) pour éviter de bloquer l'exécution du code chaîne.
Et... vous ne devriez pas ignorer les erreurs de client.send() ;)

Assurez-vous que votre serveur grpc ne nécessite pas de connexions sécurisées, sinon grpc.withtransportcredentials(insecure.newcredentials()) (connexions non sécurisées sans SSL/tls) échouera.

En général, il est recommandé de gérer la communication avec des systèmes externes (par exemple via grpc) au sein de l'application client Fabric, plutôt qu'au sein du code chaîne lui-même.

Si je souhaite simplement utiliser le code chaîne au lieu d'une application Fabric, existe-t-il un moyen de communiquer entre les organisations sur différents canaux ?

La communication entre les organisations sur différents canaux peut être complexe, car c'est un aspect fondamental de la conception de l'hyperledger que les canaux sont isolés les uns des autres pour préserver la confidentialité des données.

Vous pourriez envisager :

• Fonctions Chaincode : Une organisation peut appeler une fonction Chaincode sur son propre canal, qui à son tour appelle une fonction Chaincode sur un autre canal. Ceci est possible car les codes de chaîne peuvent être associés à plusieurs canaux.
  Notez que cette approche a une limitation : le deuxième appel de fonction n'appartient pas à la même transaction que le premier appel de fonction, donc si la première transaction échoue, elle ne peut pas être annulée.

• Double adhésion : Une organisation peut appartenir à plusieurs canaux. Par conséquent, il peut lire les données d’un canal et écrire des données sur un autre canal. Cependant, cela se fait en deux transactions distinctes, l’atomicité n’est donc pas garantie.

• Collecte de données privées (pdc) : Si l'objectif est de partager des données privées entre des organisations spécifiques (ou même sur différents canaux), la pdc peut être une option. pdc permet à un sous-ensemble défini d'organisations sur un canal d'approuver, de soumettre ou d'interroger des données privées sans avoir à distribuer les données à toutes les organisations sur le canal.

• Solutions d'interopérabilité : Il existe également des solutions plus avancées pour l'interopérabilité de la blockchain en cours de développement, telles que le protocole interledger (ilp), qui peut être utilisé pour connecter différents réseaux de structure (ou même déplacer complètement des données ou des actifs entre différents types). des réseaux blockchain).
  Cependant, ces technologies en sont encore en grande partie au stade de la recherche et du développement et ne sont peut-être pas encore prêtes à être utilisées en production.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!