如何将本地开发（含Go语言编写）的Hyperledger Fabric链码部署至Peer节点？

Hey there! Let's tackle your two Hyperledger Fabric chaincode questions with clear, actionable steps:

Migrating a locally developed chaincode to a peer node involves packaging your code, transferring it to the peer environment, and completing the install/instantiate workflow. Here's how to do it:

• Package your local chaincode
  First, bundle your chaincode files into a deployable package using the Fabric CLI. Run this command from your local development environment (make sure you have the Fabric tools installed):

  peer chaincode package my_chaincode.tar.gz -n mycc -v 1.0 -p github.com/your_org/chaincode/mycc
  

  • -n: Chaincode name (choose a unique identifier for your network)
  • -v: Version number (critical for upgrades later)
  • -p: Path to your chaincode directory (for Go, this is the module path relative to your GOPATH or module root)

• Transfer the package to the peer node
  Use a secure file transfer tool like scp to send the packaged .tar.gz file to your peer node's server:

  scp my_chaincode.tar.gz your_user@peer_node_ip:/path/to/chaincode/packages
  

  If your peer is running in a Docker container, copy the package into the container instead:

  docker cp my_chaincode.tar.gz peer0.org1.example.com:/opt/gopath/src/github.com/hyperledger/fabric/peer
  

• Install the chaincode on the peer
  Log into the peer node (or exec into the Docker container) and run the install command. Make sure you've set the necessary Fabric environment variables first (like CORE_PEER_ADDRESS, CORE_PEER_LOCALMSPID, and CORE_PEER_MSPCONFIGPATH):

  peer chaincode install my_chaincode.tar.gz
  

  You'll see a success message if the install completes without errors.

• Instantiate or upgrade the chaincode

  • If this is a new chaincode deployment, instantiate it on your target channel:

    peer chaincode instantiate -o orderer_node_ip:7050 -C my_channel -n mycc -v 1.0 -c '{"Args":["init"]}' -P "AND('Org1MSP.peer')"
    

  • If you're migrating an updated version of an existing chaincode, use the upgrade command instead:

    peer chaincode upgrade -o orderer_node_ip:7050 -C my_channel -n mycc -v 2.0 -c '{"Args":["init"]}' -P "AND('Org1MSP.peer')"
    

  • -C: Target channel name
  • -c: Initialization arguments (adjust based on your chaincode's Init method)
  • -P: Endorsement policy (tailor this to your network's organization structure)

Deploying a Go-based chaincode follows a similar workflow, but with a few Go-specific considerations. Here's the step-by-step process:

• Validate your Go chaincode structure
  Ensure your chaincode implements the required Fabric shim.Chaincode interface (with Init and Invoke methods). A minimal example looks like this:

  package main
  
  import (
      "fmt"
      "github.com/hyperledger/fabric/core/chaincode/shim"
      "github.com/hyperledger/fabric/protos/peer"
  )
  
  type MyGoChaincode struct{}
  
  func (t *MyGoChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {
      // Add your initialization logic here
      return shim.Success(nil)
  }
  
  func (t *MyGoChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
      function, args := stub.GetFunctionAndParameters()
      switch function {
      case "greet":
          return shim.Success([]byte(fmt.Sprintf("Hello, %s!", args[0])))
      default:
          return shim.Error("Unknown function called")
      }
  }
  
  func main() {
      if err := shim.Start(new(MyGoChaincode)); err != nil {
          fmt.Printf("Failed to start chaincode: %v", err)
      }
  }
  

  Also, run go mod tidy in your chaincode directory to resolve dependencies and generate go.mod/go.sum files—these are required for the peer to compile the code.

• Package the Go chaincode
  Use the same peer chaincode package command as before, making sure the -p parameter points to your Go module path:

  peer chaincode package my_go_chaincode.tar.gz -n mycc-go -v 1.0 -p github.com/your_org/chaincode/mycc-go
  

• Install and instantiate the chaincode
  Follow the same transfer, install, and instantiate/upgrade steps outlined in the first question. Note that the peer node must have a valid Go environment installed (matching your local Go version) to compile the chaincode during installation.

Key Notes for Both Workflows #

• Version consistency: Ensure your local Fabric tooling version matches the peer node's Fabric version to avoid compatibility issues.
• Environment variables: Always double-check that your peer's environment variables are correctly set before running chaincode commands—incorrect settings are a common source of errors.
• Testing: After deployment, test your chaincode with an invoke command to confirm it works:

  peer chaincode invoke -o orderer_node_ip:7050 -C my_channel -n mycc -c '{"Args":["greet","Hyperledger"]}'
  

内容的提问来源于stack exchange，提问作者user9586006