深入解析fabric的peer命令(二)分析chaincode包

最新推荐文章于 2024-06-14 17:37:13 发布
最新推荐文章于 2024-06-14 17:37:13 发布
阅读量173 收藏
点赞数
文章标签： fabric 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41683167/article/details/131024711
版权

title: 深入解析fabric的peer命令(二)分析chaincode包
date: 2023/5/30 10:24
tags: fabric区块链
categories: 区块链

分析github.com/hyperledger/fabric/internal/peer/chaincode包

一，探索思路

这个目录的tree是这样的

.
├── chaincode.go
├── common.go
├── common_test.go
├── flags_test.go
├── install.go
├── install_test.go
├── instantiate.go
├── instantiate_test.go
├── invoke.go
├── invoke_test.go
├── list.go
├── list_test.go
├── mock
│   ├── deliver_client.go
│   ├── deliver.go
│   └── signer_serializer.go
├── package.go
├── package_test.go
├── query.go
├── query_test.go
├── signpackage.go
├── signpackage_test.go
├── testdata
│   ├── connectionprofile-uneven.yaml
│   ├── connectionprofile.yaml
│   └── src
│       └── chaincodes
│           └── noop
│               └── chaincode.go
├── upgrade.go
└── upgrade_test.go

显而易见，我们要探索的命令：

peer chaincode query -C winechannel -n mycontract -c '{"Args":["GetAllWines"]}'

chaincode.go和query.go 是关键！

2，上源码

（1）chaincode.go
/*
Copyright IBM Corp. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package chaincode

import (
        "fmt"
        "time"

        "github.com/hyperledger/fabric/bccsp"
        "github.com/hyperledger/fabric/common/flogging"
        "github.com/hyperledger/fabric/internal/peer/common"
        "github.com/hyperledger/fabric/internal/peer/packaging"
        "github.com/spf13/cobra"
        "github.com/spf13/pflag"
)

const (
        chainFuncName = "chaincode"
        chainCmdDes   = "Operate a chaincode: install|instantiate|invoke|package|query|signpackage|upgrade|list."
)

var logger = flogging.MustGetLogger("chaincodeCmd")

// XXX This is a terrible singleton hack, however
// it simply making a latent dependency explicit.
// It should be removed along with the other package
// scoped variables
var platformRegistry = packaging.NewRegistry(packaging.SupportedPlatforms...)

func addFlags(cmd *cobra.Command) {
        common.AddOrdererFlags(cmd)
        flags := cmd.PersistentFlags()
        flags.StringVarP(&transient, "transient", "", "", "Transient map of arguments in JSON encoding")
}

// Cmd returns the cobra command for Chaincode
func Cmd(cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) *cobra.Command {
        addFlags(chaincodeCmd)

        chaincodeCmd.AddCommand(installCmd(cf, nil, cryptoProvider))
        chaincodeCmd.AddCommand(instantiateCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(invokeCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(packageCmd(cf, nil, nil, cryptoProvider))
        chaincodeCmd.AddCommand(queryCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(signpackageCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(upgradeCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(listCmd(cf, cryptoProvider))

        return chaincodeCmd
}

// Chaincode-related variables.
var (
        chaincodeLang         string
        chaincodeCtorJSON     string
        chaincodePath         string
        chaincodeName         string
        chaincodeUsr          string // Not used
        chaincodeQueryRaw     bool
        chaincodeQueryHex     bool
        channelID             string
        chaincodeVersion      string
        policy                string
        escc                  string
        vscc                  string
        policyMarshalled      []byte
        transient             string
        isInit                bool
        collectionsConfigFile string
        collectionConfigBytes []byte
        peerAddresses         []string
        tlsRootCertFiles      []string
        connectionProfile     string
        waitForEvent          bool
        waitForEventTimeout   time.Duration
)

var chaincodeCmd = &cobra.Command{
        Use:   chainFuncName,
        Short: fmt.Sprint(chainCmdDes),
        Long:  fmt.Sprint(chainCmdDes),
        PersistentPreRun: func(cmd *cobra.Command, args []string) {
                common.InitCmd(cmd, args)
                common.SetOrdererEnv(cmd, args)
        },
}

var flags *pflag.FlagSet

func init() {
        resetFlags()
}

// Explicitly define a method to facilitate tests
func resetFlags() {
        flags = &pflag.FlagSet{}

        flags.StringVarP(&chaincodeLang, "lang", "l", "golang",
                fmt.Sprintf("Language the %s is written in", chainFuncName))
        flags.StringVarP(&chaincodeCtorJSON, "ctor", "c", "{}",
                fmt.Sprintf("Constructor message for the %s in JSON format", chainFuncName))
        flags.StringVarP(&chaincodePath, "path", "p", common.UndefinedParamValue,
                fmt.Sprintf("Path to %s", chainFuncName))
        flags.StringVarP(&chaincodeName, "name", "n", common.UndefinedParamValue,
                "Name of the chaincode")
        flags.StringVarP(&chaincodeVersion, "version", "v", common.UndefinedParamValue,
                "Version of the chaincode specified in install/instantiate/upgrade commands")
        flags.StringVarP(&chaincodeUsr, "username", "u", common.UndefinedParamValue,
                "Username for chaincode operations when security is enabled")
        flags.StringVarP(&channelID, "channelID", "C", "",
                "The channel on which this command should be executed")
        flags.StringVarP(&policy, "policy", "P", common.UndefinedParamValue,
                "The endorsement policy associated to this chaincode")
        flags.StringVarP(&escc, "escc", "E", common.UndefinedParamValue,
                "The name of the endorsement system chaincode to be used for this chaincode")
        flags.StringVarP(&vscc, "vscc", "V", common.UndefinedParamValue,
                "The name of the verification system chaincode to be used for this chaincode")
        flags.BoolVarP(&isInit, "isInit", "I", false,
                "Is this invocation for init (useful for supporting legacy chaincodes in the new lifecycle)")
        flags.BoolVarP(&getInstalledChaincodes, "installed", "", false,
                "Get the installed chaincodes on a peer")
        flags.BoolVarP(&getInstantiatedChaincodes, "instantiated", "", false,
                "Get the instantiated chaincodes on a channel")
        flags.StringVar(&collectionsConfigFile, "collections-config", common.UndefinedParamValue,
                "The fully qualified path to the collection JSON file including the file name")
        flags.StringArrayVarP(&peerAddresses, "peerAddresses", "", []string{common.UndefinedParamValue},
                "The addresses of the peers to connect to")
        flags.StringArrayVarP(&tlsRootCertFiles, "tlsRootCertFiles", "", []string{common.UndefinedParamValue},
                "If TLS is enabled, the paths to the TLS root cert files of the peers to connect to. The order and number of certs specified should match the --peerAddresses flag")
        flags.StringVarP(&connectionProfile, "connectionProfile", "", common.UndefinedParamValue,
                "Connection profile that provides the necessary connection information for the network. Note: currently only supported for providing peer connection information")
        flags.BoolVar(&waitForEvent, "waitForEvent", false,
                "Whether to wait for the event from each peer's deliver filtered service signifying that the 'invoke' transaction has been committed successfully")
        flags.DurationVar(&waitForEventTimeout, "waitForEventTimeout", 30*time.Second,
                "Time to wait for the event from each peer's deliver filtered service signifying that the 'invoke' transaction has been committed successfully")
        flags.BoolVarP(&createSignedCCDepSpec, "cc-package", "s", false,
                "create CC deployment spec for owner endorsements instead of raw CC deployment spec")
        flags.BoolVarP(&signCCDepSpec, "sign", "S", false,
                "if creating CC deployment spec package for owner endorsements, also sign it with local MSP")
        flags.StringVarP(&instantiationPolicy, "instantiate-policy", "i", "",
                "instantiation policy for the chaincode")
}

func attachFlags(cmd *cobra.Command, names []string) {
        cmdFlags := cmd.Flags()
        for _, name := range names {
                if flag := flags.Lookup(name); flag != nil {
                        cmdFlags.AddFlag(flag)
                } else {
                        logger.Fatalf("Could not find flag '%s' to attach to command '%s'", name, cmd.Name())
                }
        }
}
（2）query.go
/*
Copyright IBM Corp. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package chaincode

import (
        "errors"
        "fmt"

        "github.com/hyperledger/fabric/bccsp"
        "github.com/spf13/cobra"
)

var chaincodeQueryCmd *cobra.Command

// queryCmd returns the cobra command for Chaincode Query
func queryCmd(cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) *cobra.Command {
        chaincodeQueryCmd = &cobra.Command{
                Use:       "query",
                Short:     fmt.Sprintf("Query using the specified %s.", chainFuncName),
                Long:      fmt.Sprintf("Get endorsed result of %s function call and print it. It won't generate transaction.", chainFuncName),
                ValidArgs: []string{"1"},
                RunE: func(cmd *cobra.Command, args []string) error {
                        return chaincodeQuery(cmd, cf, cryptoProvider)
                },
        }
        flagList := []string{
                "ctor",
                "name",
                "channelID",
                "peerAddresses",
                "tlsRootCertFiles",
                "connectionProfile",
        }
        attachFlags(chaincodeQueryCmd, flagList)

        chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryRaw, "raw", "r", false,
                "If true, output the query value as raw bytes, otherwise format as a printable string")
        chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryHex, "hex", "x", false,
                "If true, output the query value byte array in hexadecimal. Incompatible with --raw")

        return chaincodeQueryCmd
}

func chaincodeQuery(cmd *cobra.Command, cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) error {
        if channelID == "" {
                return errors.New("The required parameter 'channelID' is empty. Rerun the command with -C flag")
        }
        // Parsing of the command line is done so silence cmd usage
        cmd.SilenceUsage = true

        var err error
        if cf == nil {
                cf, err = InitCmdFactory(cmd.Name(), true, false, cryptoProvider)
                if err != nil {
                        return err
                }
        }

        return chaincodeInvokeOrQuery(cmd, false, cf)
}

三，逐句分析chaincode.go

  1. 导入依赖包：
import (
        "fmt"
        "time"

        "github.com/hyperledger/fabric/bccsp"
        "github.com/hyperledger/fabric/common/flogging"
        "github.com/hyperledger/fabric/internal/peer/common"
        "github.com/hyperledger/fabric/internal/peer/packaging"
        "github.com/spf13/cobra"
        "github.com/spf13/pflag"
)

这部分代码导入了需要使用的包。import 关键字后面的括号里是导入的包的路径。

  1. 常量和全局变量：
const (
        chainFuncName = "chaincode"
        chainCmdDes   = "Operate a chaincode: install|instantiate|invoke|package|query|signpackage|upgrade|list."
)

var logger = flogging.MustGetLogger("chaincodeCmd")
var platformRegistry = packaging.NewRegistry(packaging.SupportedPlatforms...)

这里定义了一个常量 chainFuncName 和一个变量 chainCmdDes。logger 和 platformRegistry 是全局变量。

  1. 辅助函数：
func addFlags(cmd *cobra.Command) {
        common.AddOrdererFlags(cmd)
        flags := cmd.PersistentFlags()
        flags.StringVarP(&transient, "transient", "", "", "Transient map of arguments in JSON encoding")
}

这是一个名为 addFlags 的函数。它接受一个 *cobra.Command 类型的参数 cmd。在函数内部，它调用 common.AddOrdererFlags(cmd) 和 cmd.PersistentFlags() 函数，然后使用 flags.StringVarP() 函数将一个标志 transient 添加到 cmd 中。

  1. Cmd 函数：
func Cmd(cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) *cobra.Command {
        addFlags(chaincodeCmd)

        chaincodeCmd.AddCommand(installCmd(cf, nil, cryptoProvider))
        chaincodeCmd.AddCommand(instantiateCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(invokeCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(packageCmd(cf, nil, nil, cryptoProvider))
        chaincodeCmd.AddCommand(queryCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(signpackageCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(upgradeCmd(cf, cryptoProvider))
        chaincodeCmd.AddCommand(listCmd(cf, cryptoProvider))

        return chaincodeCmd
}

这是一个名为 Cmd 的函数。它接受两个参数：cf 是 *ChaincodeCmdFactory 类型，cryptoProvider 是 bccsp.BCCSP 类型。该函数返回一个 *cobra.Command 类型的指针。

  • 在函数内部，调用 addFlags(chaincodeCmd) 函数为 chaincodeCmd 添加标志。
  • 使用 chaincodeCmd.AddCommand() 函数将多个命令添加到 chaincodeCmd 中，这些命令包括 installCmd、instantiateCmd、invokeCmd、packageCmd、queryCmd、signpackageCmd、upgradeCmd 和 listCmd。
  • 返回 chaincodeCmd。
5.变量定义：
var (
        chaincodeLang         string
        chaincodeCtorJSON     string
        chaincodePath         string
        chaincodeName         string
        chaincodeUsr          string // Not used
        chaincodeQueryRaw     bool
        chaincodeQueryHex     bool
        channelID             string
        chaincodeVersion      string
        policy                string
        escc                  string
        vscc                  string
        policyMarshalled      []byte
        transient             string
        isInit                bool
        collectionsConfigFile string
        collectionConfigBytes []byte
        peerAddresses         []string
        tlsRootCertFiles      []string
        connectionProfile     string
        waitForEvent          bool
        waitForEventTimeout   time.Duration
)

这是一组变量的定义，它们将在后续的代码中使用。

  1. chaincodeCmd 命令：
var chaincodeCmd = &cobra.Command{
        Use:   chainFuncName,
        Short: fmt.Sprint(chainCmdDes),
        Long:  fmt.Sprint(chainCmdDes),
        PersistentPreRun: func(cmd *cobra.Command, args []string) {
                common.InitCmd(cmd, args)
                common.SetOrdererEnv(cmd, args)
        },
}

这是一个名为 chaincodeCmd 的命令。它是一个 *cobra.Command 类型的变量。在这个命令的定义中，我们指定了 Use、Short 和 Long 字段来描述命令的用法和说明。此外，我们还定义了一个 PersistentPreRun 回调函数，在命令运行之前会执行这个函数。

  1. flags 变量和 resetFlags 函数：
var flags *pflag.FlagSet

func init() {
        resetFlags()
}

func resetFlags() {
        flags = &pflag.FlagSet{}

        // 标志的定义
        // ...
}

这里定义了一个 flags 变量，它是 pflag.FlagSet 类型的指针。在 init 函数中，调用了 resetFlags 函数，该函数将 flags 设置为一个新的 FlagSet 对象。

  1. attachFlags 函数：
func attachFlags(cmd *cobra.Command, names []string) {
        cmdFlags := cmd.Flags()
        for _, name := range names {
                if flag := flags.Lookup(name); flag != nil {
                        cmdFlags.AddFlag(flag)
                } else {
                        logger.Fatalf("Could not find flag '%s' to attach to command '%s'", name, cmd.Name())
                }
        }
}

这是一个名为 attachFlags 的函数。它接受一个 *cobra.Command 类型的参数 cmd 和一个字符串切片 names。函数内部通过 cmd.Flags() 获取命令的标志集合，并循环遍历 names，然后通过 flags.Lookup() 函数查找对应的标志，并将其添加到命令的标志集合中。

四，逐句分析query.go

  1. 导入依赖包：
import (
        "errors"
        "fmt"

        "github.com/hyperledger/fabric/bccsp"
        "github.com/spf13/cobra"
)

这部分代码导入了需要使用的包。import 关键字后面的括号里是导入的包的路径。

  1. 声明全局变量：
var chaincodeQueryCmd *cobra.Command

这里声明了一个全局变量 chaincodeQueryCmd，它是一个指向 cobra.Command 类型的指针。

  1. queryCmd 函数：
func queryCmd(cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) *cobra.Command {
        chaincodeQueryCmd = &cobra.Command{
                Use:       "query",
                Short:     fmt.Sprintf("Query using the specified %s.", chainFuncName),
                Long:      fmt.Sprintf("Get endorsed result of %s function call and print it. It won't generate transaction.", chainFuncName),
                ValidArgs: []string{"1"},
                RunE: func(cmd *cobra.Command, args []string) error {
                        return chaincodeQuery(cmd, cf, cryptoProvider)
                },
        }
        flagList := []string{
                "ctor",
                "name",
                "channelID",
                "peerAddresses",
                "tlsRootCertFiles",
                "connectionProfile",
        }
        attachFlags(chaincodeQueryCmd, flagList)

        chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryRaw, "raw", "r", false,
                "If true, output the query value as raw bytes, otherwise format as a printable string")
        chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryHex, "hex", "x", false,
                "If true, output the query value byte array in hexadecimal. Incompatible with --raw")

        return chaincodeQueryCmd
}

这是一个名为 queryCmd 的函数。它接受两个参数：cf 和 cryptoProvider，并返回一个 *cobra.Command 类型的指针。

  • 函数内部创建了一个新的 cobra.Command 实例，并将其赋值给 chaincodeQueryCmd 变量。Use 字段表示命令的名称为 “query”，Short 字段提供了对该命令的简短描述，Long 字段提供了更详细的描述，ValidArgs 字段指定了有效的参数列表。

  • 在 RunE 字段中定义了一个匿名函数，该函数将调用 chaincodeQuery 函数并返回其结果。

  • 通过 attachFlags 函数将一组标志（flagList）附加到 chaincodeQueryCmd 中。

  • 使用 chaincodeQueryCmd.Flags().BoolVarP() 函数定义了两个布尔类型的标志：chaincodeQueryRaw 和 chaincodeQueryHex。

  1. chaincodeQuery 函数：
func chaincodeQuery(cmd *cobra.Command, cf *ChaincodeCmdFactory, cryptoProvider bccsp.BCCSP) error {
        if channelID == "" {
                return errors.New("The required parameter 'channelID' is empty. Rerun the command with

 -C flag")
        }
        // Parsing of the command line is done so silence cmd usage
        cmd.SilenceUsage = true

        var err error
        if cf == nil {
                cf, err = InitCmdFactory(cmd.Name(), true, false, cryptoProvider)
                if err != nil {
                        return err
                }
        }

        return chaincodeInvokeOrQuery(cmd, false, cf)
}

这是一个名为 chaincodeQuery 的函数。它接受三个参数：cmd 是一个 *cobra.Command 类型，cf 是 *ChaincodeCmdFactory 类型，cryptoProvider 是 bccsp.BCCSP 类型。该函数返回一个 error 类型的值。

  • 首先，检查 channelID 是否为空字符串，如果为空，则返回一个错误。
  • 设置 cmd.SilenceUsage 为 true，以静默输出命令使用说明。
  • 如果 cf 为 nil，则调用 InitCmdFactory 函数初始化 cf，并将其赋值给 cf 变量。
  • 调用 chaincodeInvokeOrQuery 函数执行链码的调用或查询操作，并返回其结果。

五，继续分析chaincodeInvokeOrQuery函数

https://xiutuuu.cloud/2023/06/03/%E6%B7%B1%E5%85%A5%E8%A7%A3%E6%9E%90fabric%E7%9A%84peer%E5%91%BD%E4%BB%A43/

酒楼丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入解析fabric的peer命令(终篇)fabric-protos-go
qq_41683167的博客
06-03 168
sequenceDiagram Title peer chaincode invoke命令到底都干了什么participant Peer chaincode invoke指令participant EndorserClient 接口。
Fabric源码分析之二整体架构和流程
01-07
fabric可以从逻辑架构和系统架构两种层面上来解析，先看一下二者的结构图： 1、逻辑架构图： 从逻辑架构构图上来理解Fabric的整体的逻辑，联盟链和公链的不同之处在于，其逻辑结构有着完全的不同。比如看上面的逻辑...
2021-03-26
weixin_44574761的博客
03-26 140
peer chaincode package 将指定的链码打包为CDS（Chaincode Deployment Spec：链码部署规范）格式。 确保相同的智能合约包可以在多个Peer节点上安装的一致性。 使用方法 peer chaincode package [flags] 例子 peer chaincode package ccpack.out -n mycc -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_exampl
fabric 2.0, chaincode package & lifecycle
Kingwel Blog
03-12 852
@[TOC]Chaincode and new lifecycle Chaincode as an external service Fabric v2.0 supports chaincode deployment and execution outside of Fabric that enables users to manage a chaincode runtime independen...
深入解析fabric的peer命令（一）
qq_41683167的博客
06-03 253
mainCmd。
K8s无法感知到Fabric Chaincode容器的解决方案
01-20
然而，在启动fabric-peer的的env里，通过CORE_VM_ENDPOINT=unix:///var/run/docker.sock能够让peer节点创建并启动fabric chaincode容器（链码容器的启动是通过Docker API启动的）。 在使用单机docker-compose的情况...
Hyperledger Fabric v1.4.1 二进制脚本文件bin
09-28
Hyperledger Fabric2.0.0二进制文件：configtxgen、configtxlator、cryptogen、discover、fabric-ca-client、idemixgen、orderer、peer
区块链Fabric 排序、二次开发
01-20
 排序（Orderer）指对区块链网络中不同通道产生的交易进行排序，并广播给节点（Peer）。排序（Orderer）是以可插拔组件的方式实现，目前分为SOLO和Kafka两种类型。  SOLO：仅有一个Orderer服务节点负责接收交易...
Fabric 1orderer+1peer 部署文件
08-21
自定义多机架构部署，包括1个orderer服务器+一个peer节点服务器，配置文件直接拷贝至不同服务器中，docker-compse运行即可。
长亭雷池部署
最新发布
hellodaoyan的博客
06-14 359
然后把这个文件下载下来这是雷池的源文件 这个网上找吧 不知道能不能发给你们。之前在自己的虚拟机docker上试过安装github上的雷池。现在重新安装了ubuntu 在我的ubuntu上安装一个雷池。web账号：admin/pmdmwtMp 这个应该行吧。手工进行安装前环境检查，或在运行安装包的目录下，然后 下面第二个命令需要root 我试过了。这个不知道干嘛的然后应该后面会有用把。WAF 安装到 /data/基本就是照着ppt做就行很简单。，如果没有安装则进行自动安装。节点状态」确认节点正常。
LoadBalance客户端负载均衡
小生不才的博客
06-11 996
LB负载均衡(Load Balance)是什么简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用），常见的负载均衡有软件Nginx，LVS，硬件 F5等spring-cloud-starter-loadbalancer组件是什么Spring Cloud LoadBalancer是由SpringCloud官方提供的一个开源的、简单易用的客户端负载均衡器，它包含在SpringCloud-commons中用它来替换了以前的Ribbon组件。
Kubesphere替换出错的pod
kelven2004的专栏
06-14 125
碰到镜像里面出现默认镜像拉取不到的情况，更改yaml里面的配置即可。
nginx rewrite地址重写
2401_83883919的博客
06-12 980
（3）将请求http://www.xy102.com/discuz/index.php 跳转到http://www.xy101.com/discuz/index.php ，保证原域名后面的uri路径不变。（4）将请求http://discuz.xy101.com/index.php 的访问跳转到http://www.xy101.com/discuz/index.php ，保证原域名后面的uri路径不变。优先级：精准匹配 = > 最长前缀匹配 ^~ > 正则匹配 ~ ~*!root 网页根目录;
【Git】Windows下使用可视化工具Sourcetree
qq_45306739的博客
06-10 378
登录码云Gitee.com，在右上角我的主页–个人设置–安全设置–SSH公钥，将刚才的内容添加进去，输入密码检查后则会添加成功，该计算机本地则与云端仓库建立关联。首先安装Git，然后将本地和远端仓库建立联系，无论是Windows还是Linux下的工具只是将Git命令可视化。之前文章介绍过Linux系统中的Git工具：git cola。跳过Install的登录，直接一路安装，选择安装Git。如果第一次链接出现警告，输入yes验证后即可成功。用记事本打开id_rsa.pub，复制所有内容。
有声读物管理平台Booksonic-Air
wbsu2004的博客
06-14 1520
Booksonic 是一个无论您身在何处都可以访问您拥有的有声读物的平台。
k8s中的pod域名解析失败定位案例
pcj_888的博客
06-12 276
k8s中的pod域名解析失败定位
Centos7.9使用kubeadm部署K8S单机环境
codelearning的专栏
06-11 706
使用kubeadm部署一个k8s单机环境。
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1128
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
fabric peer0和peer1有什么区别
05-24
在Hyperledger Fabric中，peer节点是网络中的核心节点。peer0和peer1都是同一组织中的peer节点，它们具有相同的功能，但在网络中具有不同的身份。 peer0是组织中的领导节点，它通常负责维护区块链账本和处理交易。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值