Grpc入门整理

最新推荐文章于 2023-08-16 09:14:13 发布
最新推荐文章于 2023-08-16 09:14:13 发布
阅读量787 收藏 2
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoguanghe/article/details/117389050
版权

1.Protobuf3入门学习文档 

本文是对Protobuf3（以下简称pb）官方文档的学习笔记，大部分示例摘自官方。

原文：https://developers.google.com/protocol-buffers/docs/proto3

一个简单的例子

syntax = "proto3";

message SearchRequest {
  string query = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
}

版本号

对于一个pb文件而言，文件首个非空、非注释的行必须注明pb的版本，即syntax = "proto3";，否则默认版本是proto2。

Message

一个message类型看上去很像一个Java class，由多个字段组成。每一个字段都由类型、名称组成，位于等号右边的值不是字段默认值，而是数字标签，可以理解为字段身份的标识符，类似于数据库中的主键，不可重复，标识符用于在编译后的二进制消息格式中对字段进行识别，一旦你的pb消息投入使用，字段的标识就不应该再改变。数字标签的范围是[1, 536870911]，其中19000～19999是保留数字。

类型

每个字段的类型（int32,string）都是scalar的类型，和其他语言类型的对比如下：

 

修饰符

如果一个字段被repeated修饰，则表示它是一个列表类型的字段，如下所示：

...
message SearchRequest {
  repeated string args = 1 // 等价于java中的List<string> args
}

如果你希望可以预留一些数字标签或者字段可以使用reserved修饰符：

message Foo {
  reserved 2, 15, 9 to 11;
  reserved "foo", "bar";
  string foo = 3 // 编译报错，因为‘foo’已经被标为保留字段
}

默认值

  1. string类型的默认值是空字符串
  2. bytes类型的默认值是空字节
  3. bool类型的默认值是false
  4. 数字类型的默认值是0
  5. enum类型的默认值是第一个定义的枚举值
  6. message类型（对象，如上文的SearchRequest就是message类型）的默认值与 语言 相关
  7. repeated修饰的字段默认值是空列表

如果一个字段的值等于默认值（如bool类型的字段设为false），那么它将不会被序列化，这样的设计是为了节省流量。

枚举

每个枚举值有对应的数值，数值不一定是连续的。第一个枚举值的数值必须是0且至少有一个枚举值，否则编译报错。编译后编译器会为你生成对应语言的枚举类。

message SearchRequest {
  string query = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
  enum Corpus {
    UNIVERSAL = 0;
    WEB = 1;
    IMAGES = 2;
    LOCAL = 3;
    NEWS = 4;
    PRODUCTS = 5;
    VIDEO = 6;
  }
  Corpus corpus = 4;
}

一个数值可以对应多个枚举值，必须标明option allow_alias = true;

enum EnumAllowingAlias {
  option allow_alias = true;
  UNKNOWN = 0;
  STARTED = 1;
  RUNNING = 1;
}

可以使用MessageType.EnumType的形式引用定义在其它message类型中的枚举。

由于编码原因，出于效率考虑，官方不推荐使用负数作为枚举值的数值。

使用其它的message类型

除了上述基本类型，一个字段的类型也可以是其它的message类型：

message SearchResponse {
  repeated Result results = 1;
}

message Result {
  string url = 1;
  string title = 2;
  repeated string snippets = 3;
}

从上面的例子可以看到，一个.proto文件中可以定义多个message。我们也可以引用定义在其它文件中的message：

import "myproject/other_protos.proto"; // 这样就可以引用在other_protos.proto文件中定义的message

不能导入不使用的.proto文件。

import还有一种特殊的语法，先看下面的例子：

// new.proto
// 原来在old.proto文件中的定义移到这里

 

// old.proto
import public "new.proto"; // 把引用传递给上层使用方
import "other.proto"; // 引用old.proto本身使用的定义

// client.proto
import "old.proto";
// 此处可以引用old.proto和new.proto中的定义，但不能使用other.proto中的定义

从这个例子中可以看到import关键字导入的定义仅在当前文件有效，不能被上层使用方引用（client.proto无法使用other.proto中的定义），而import public关键字导入的定义可以被上层使用方引用（client.proto可以使用new.proto中的定义），import public的功能可以看作是import的超集，在import的功能上还具有传递引用的作用。

嵌套类型

你可以在一个message类型中定义另一个message类型，并且可以一直嵌套下去，类似Java的内部类：

message SearchResponse {
  message Result {
    string url = 1;
    string title = 2;
    repeated string snippets = 3;
  }
  repeated Result results = 1;
}

可以使用Parent.Type的形式引用嵌套的message：

message SomeOtherMessage {
  SearchResponse.Result result = 1;
}

Any

Any类型允许包装任意的message类型：

import "google/protobuf/any.proto";

message Response {
    google.protobuf.Any data = 1;
}

可以通过pack()和unpack()（方法名在不同的语言中可能不同）方法装箱/拆箱，以下是Java的例子：

People people = People.newBuilder().setName("proto").setAge(1).build();
// protoc编译后生成的message类
Response r = Response.newBuilder().setData(Any.pack(people)).build();
// 使用Response包装people

System.out.println(r.getData().getTypeUrl());
// type.googleapis.com/example.protobuf.people.People
System.out.println(r.getData().unpack(People.class).getName());
// proto

Any对包装的类型会生成一个URL，默认是type.googleapis.com/packagename.messagename（在Java中可以通过这个特性进行反射操作）。

Oneof

如果你有一些字段同时最多只有一个能被设置，可以使用oneof关键字来实现，任何一个字段被设置，其它字段会自动被清空（被设为默认值）：

message SampleMessage {
  oneof test_oneof {
    string name = 4;
    SubMessage sub_message = 9;
  }
}

oneof块中的字段不支持repeated。

Maps

pb中也可以使用map类型（官方并不认为是一种类型，此处称之为类型仅便于理解），绝大多数scalar类型都可以作为key，除了浮点型和bytes，枚举型也不能作为key，value可以是除了map以外的任意类型：

// map<key_type, value_type> map_field = N;
map<string, Project> projects = 3;

map类型字段不支持repeated，value的顺序是不定的。

map其实是一种语法糖，它等价于以下形式：

message MapFieldEntry {
  key_type key = 1;
  value_type value = 2;
}

repeated MapFieldEntry map_field = N;

包

你可以用指定package以避免类型命名冲突：

package foo.bar;
message Open { ... }

然后可以用类型的全限定名来引用它：

message Foo {
  ...
  foo.bar.Open open = 1;
  ...
}

指定包名后，会对生成的代码产生影响，以Java为例，生成的类会以你指定的package作为包名。

JSON映射

pb支持和JSON互相转换。如果一个字段不存在JSON数据中或者为null，那么pb中会被赋为该字段的默认值，反之，如果一个字段在pb中是默认值，那么不会写到JSON数据中以节省空间。

选项

选项不对message的定义产生任何的效果，只会在一些特定的场景中起到作用，下面是一部分例子，完整的选项列表可以前往google/protobuf/descriptor.proto查看（Java语言可以在jar包中找到）：

  1. option java_package = "com.example.foo"; 编译器为以此作为生成的Java类的包名，如果没有该选项，则会以pb的package作为包名。
  2. option java_multiple_files = true; 该选项为true时，生成的Java类将是包级别的，否则会在一个包装类中。
  3. option optimize_for = CODE_SIZE; 该选项会对生成的类产生影响，作用是根据指定的选项对代码进行不同方面的优化。
  4. int32 old_field = 6 [deprecated=true]; 把字段标为过时的。

Java例子

最后，用Java写了一个简单的例子：Github

作者：宇宙最强架构师
链接：https://www.jianshu.com/p/ea656dc9b037
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.IDEA java开发 grpc框架的服务端和客户端--helloworld实例

参考：

  1. java下使用gRPC的helloworld的demo实现https://blog.csdn.net/u013992365/article/details/81698531#%E6%96%B0%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%99%AE%E9%80%9A%E7%9A%84maven%E9%A1%B9%E7%9B%AE
  2. grpc官方文档中文版 http://doc.oschina.net/grpc?t=58008
  3. 示例：https://github.com/grpc/grpc-java/tree/master/examples/src/main/java/io/grpc/examples

具体实施步骤：

1、新建一个普通的Maven项目：

点击下一步，再点击Finsh。

2、配置pom文件，导入grpc的依赖和插件

全部的pom内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.grpcprojects</groupId>
    <artifactId>grpcExercise3</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <properties>
        <grpc-version>1.20.0</grpc-version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-core</artifactId>
            <version>${grpc-version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>${grpc-version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc-version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc-version}</version>
        </dependency>
    </dependencies>
 
    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.5.0.Final</version>
            </extension>
        </extensions>
 
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.9.1:exe:${os.detected.classifier}</pluginArtifact>
                    <protoSourceRoot>src/main/proto</protoSourceRoot>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
 
</project>

添加好依赖之后的显示：

添加之后选择右下键出现的import change，就能在Maven Projects中看到添加的依赖了。

3、编写helloworld.proto文件

在项目main目录下新建一个proto文件夹，再在此文件夹下创建一个helloworld.proto文件

helloworld.proto（跟官网上的一样）中的代码如下：

syntax = "proto3";
 
option java_multiple_files = true;
option java_package = "io.grpc.examples.helloworld";
option java_outer_classname = "HelloWorldProto";
option objc_class_prefix = "HLW";
 
package helloworld;
 
// The greeting service definition.
service Greeter {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}
 
// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}
 
// The response message containing the greetings
message HelloReply {
    string message = 1;
}

编译helloworld.proto文件，编译此文件有两种方法，第一种使用protoc.exe和protoc-gen-grpc-java插件进行编译。第二种方法是用刚才在项目里边添加的插件进行编译。

第一种：使用protoc.exe和protoc-gen-grpc-java插件进行编译

下载protoc.exe 工具 ， 下载地址：https://github.com/protocolbuffers/protobuf/releases

 下载protoc-gen-grpc 插件  , 下载地址: http://jcenter.bintray.com/io/grpc/protoc-gen-grpc-java/

将protoc.exe和protoc-gen-grpc插件放到main目录中：

在项目的terminal窗口中执行如下两条指令：

执行完每条指令之后，窗口应该不会出现任何信息，在项目文件目录中会添加如下文件：

第二种方法：用刚才在项目里边添加的插件进行编译

在分割线下边

4、添加客户端和服务端代码

我是直接从官网上直接拿过来的代码，分别为HelloWorldClient.java和HelloWorldServer.java

HelloWorldClient.java代码如下：

/*
 * Copyright 2015 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
package helloworld;
 
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;
import io.grpc.examples.helloworld.GreeterGrpc;
import io.grpc.examples.helloworld.HelloReply;
import io.grpc.examples.helloworld.HelloRequest;
 
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * A simple client that requests a greeting from the {@link HelloWorldServer}.
 */
public class HelloWorldClient {
  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
 
  private final ManagedChannel channel;
  private final GreeterGrpc.GreeterBlockingStub blockingStub;
 
  /** Construct client connecting to HelloWorld server at {@code host:port}. */
  public HelloWorldClient(String host, int port) {
    this(ManagedChannelBuilder.forAddress(host, port)
        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
        // needing certificates.
        .usePlaintext()
        .build());
  }
 
  /** Construct client for accessing HelloWorld server using the existing channel. */
  HelloWorldClient(ManagedChannel channel) {
    this.channel = channel;
    blockingStub = GreeterGrpc.newBlockingStub(channel);
  }
 
  public void shutdown() throws InterruptedException {
    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
  }
 
  /** Say hello to server. */
  public void greet(String name) {
    logger.info("Will try to greet " + name + " ...");
    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
    HelloReply response;
    try {
      response = blockingStub.sayHello(request);
    } catch (StatusRuntimeException e) {
      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
      return;
    }
    logger.info("Greeting: " + response.getMessage());
  }
 
  /**
   * Greet server. If provided, the first element of {@code args} is the name to use in the
   * greeting.
   */
  public static void main(String[] args) throws Exception {
    HelloWorldClient client = new HelloWorldClient("localhost", 50051);
    try {
      /* Access a service running on the local machine on port 50051 */
      String user = "world";
      if (args.length > 0) {
        user = args[0]; /* Use the arg as the name to greet if provided */
      }
      client.greet(user);
    } finally {
      client.shutdown();
    }
  }
}

HelloWorldServer.java代码如下：

/*
 * Copyright 2015 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
package helloworld;
 
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.examples.helloworld.GreeterGrpc;
import io.grpc.examples.helloworld.HelloReply;
import io.grpc.examples.helloworld.HelloRequest;
import io.grpc.stub.StreamObserver;
import java.io.IOException;
import java.util.logging.Logger;
 
/**
 * Server that manages startup/shutdown of a {@code Greeter} server.
 */
public class HelloWorldServer {
  private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
 
  private Server server;
 
  private void start() throws IOException {
    /* The port on which the server should run */
    int port = 50051;
    server = ServerBuilder.forPort(port)
        .addService(new GreeterImpl())
        .build()
        .start();
    logger.info("Server started, listening on " + port);
    Runtime.getRuntime().addShutdownHook(new Thread() {
      @Override
      public void run() {
        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
        System.err.println("*** shutting down gRPC server since JVM is shutting down");
        HelloWorldServer.this.stop();
        System.err.println("*** server shut down");
      }
    });
  }
 
  private void stop() {
    if (server != null) {
      server.shutdown();
    }
  }
 
  /**
   * Await termination on the main thread since the grpc library uses daemon threads.
   */
  private void blockUntilShutdown() throws InterruptedException {
    if (server != null) {
      server.awaitTermination();
    }
  }
 
  /**
   * Main launches the server from the command line.
   */
  public static void main(String[] args) throws IOException, InterruptedException {
    final HelloWorldServer server = new HelloWorldServer();
    server.start();
    server.blockUntilShutdown();
  }
 
  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
 
    @Override
    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
      responseObserver.onNext(reply);
      responseObserver.onCompleted();
    }
  }
}

5、最终的文件结构

6、执行服务端和客户端代码

先执行HelloWorldServer.java,再HelloWorldClient.java，得如下运行结果，正面我们的gprc通信成功了。

服务端显示如下：

客户端显示如下：

步骤1,2和上边完全相同，此处从步骤3的第二种方法开始说。

第二种方法：用刚才在项目里边添加的插件进行编译。

  • 右击Maven.Projects\protobuf\protobuf:compile ，选择run，生成用于序列化的java文件。
  • 再右击Maven.Projects\protobuf\protobuf:compile-custom，选择run，生成用于rpc的java代码。

执行完这两步，会产生的文件为：

但是在执行这两步的过程中，控制台会出现报错的信息，但是在后边服务端和客户端运行的时候并没有报别的错误。

哪位大佬能解决这个问题，麻烦请告知一下，多谢了。

4、客户端和服务端的代码和上边写的一样

5、项目文件目录如下：

6、最后的运行结果（和上边的运行结果一样，并没有报错误）

服务端的显示：

客户端的显示：

引自：https://blog.csdn.net/qq_29319189/article/details/93539198

3.gRPC 中泛化调用服务接口

https://blog.csdn.net/u013360850/article/details/115414627

 

清风思月
关注
专栏目录
三种传递gRPC动态参数方式的使用体验
kevin_tech的博客，微信搜「网管叨bi叨」
11-12 4757
gRPC是一个远程调用框架，使用Protobuf做为信息的载体来完成客户端和服务端的数据传输。关于怎么定义Protobuf消息、搭建gRPC服务在之前的系列文章中都有提及，今天来说一下在...
gRPC + Protobuf专题介绍
最新发布
Chaos_Tree的博客
12-31 1002
Protocol Buffers是一种与语言、平台无关的可扩展机制，用于序列化结构化数据。它类似于JSON，但是更轻量、速度更快，而且可以生成原生语言绑定。一旦定义了数据的结构化方式，就可以通过多种语言使用特殊的生成源代码来读写结构化数据。Protocol Buffers包括文件中创建的定义语言、proto编译器为数据交互生成的代码、特定语言的运行库以及写入文件(或通过网络连接发送)的数据序列化格式。针对大小不超过几兆字节的类型化、结构化数据包，Protocol Buffers提供了一种序列化格式。
gRPC（二）入门：Protobuf入门
林钟一的博客
10-31 3000
通过protubuf文档先了解一下protobuf语法。点击跳转Protocol Buffers ( Protobuf ) 是一种免费的开源 跨平台数据格式，用于序列化结构化数据。它是谷歌公司开发的一种数据描述语言，并于2008年开源。Protobuf刚开源时的定位类似于XML、JSON等数据描述语言，通过附带工具生成代码并实现将结构化数据序列化的功能。Protocol Buffers 是一种与语言、平台无关，可扩展的序列化结构化数据的方法，常用于通信协议，数据存储等等。
gRPC
jiongjiong 的专栏
08-21 569
Protocol buffer data is structured as messages, where each message is a small logical record of information containing a series of name-value pairs called fields. Service method: Unary RPC Server s...
GRPC一个接口根据某一参数不同的值而返回多套出参
qq_36411271的博客
03-31 754
GRPC 多种出参
分布式学习（1）gRPC python@protobuf_grpc
水野与小太郎的博客
03-04 579
一、安装 gRPC 的安装： $ pip install grpcio ProtoBuf 相关的 python 依赖库： $ pip install protobuf python grpc 的 protobuf 编译工具： $ pip install grpcio-tools 二、protobuf 文档 信息结构体 message message SearchRequest {...
gRPC----gRPC简单介绍
AImprobityAngel的博客
06-15 2094
GRPC介绍简介概述特点使用场景接口定义定义消息定义服务 简介 gRPC 是由Google一个高性能、开源的RPC框架，面向移动和HTTP/2设计。目前由C、JAVA等语言版本。用一句话也就是说gRPC提供一套机制，使得应用程序之间能够进行通信，且遵从CS模型，在使用的时候调用Server端接口向本地方法一样。 摘自官网的一个典型gRPC结构图，如图。 gRPC 默认使用protocol buf...
micro-starter-kit：Cloud Native GoLang微服务-gRPC，GraphQL
02-03
带有REST Gateway的gRPC微服务 使用输入验证 配置-可插拔源，可合并配置，安全恢复 可自定义的日志记录 CRUD使用示例，， 接下来？ 通过GORM代码或使用 ？ 依赖注入，接下来尝试吗？ 多阶段多目标Dockerfile...
SpringBoot整合高性能微服务框架 gRPC
公众号：微观技术
03-13 1259
Spring Boot 作为主流微服务框架，拥有成熟的社区生态。市场应用广泛，为了方便大家，整理了一个基于spring boot的常用中间件快速集成入门系列手册，涉及RPC、缓存、消息队列、分库分表、注册中心、分布式配置等常用开源组件，大概有几十篇文章，陆续会开放出来，感兴趣同学可以关注&收藏 1、简介 在 gRPC 里，客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得我们能够更容易地创建分布式应用和服务。 gRPC 基于 HTTP/2 标准设计，带来诸如双.
10分钟学会 gRPC
CCqwas的博客
03-16 347
介绍 我猜测大部分长期使用Java的开发者应该较少会接触gRPC，毕竟在Java圈子里大部分使用的还是Dubbo/SpringClound这两类服务框架。 我也是近段时间有机会从零开始重构业务才接触到gRPC的，当时选择gRPC时也有几个原因： 基于云原生的思路开发部署项目，而在云原生中gRPC几乎已经是标准的通讯协议了。 开发语言选择了 Go，在 Go 圈子中gRPC显然是更好的选择。 公司内部有部分业务使用的是Python开发，在多语言兼容性上...
grpc、https、oauth2等认证专栏实战20：etcd认证介绍
码二哥的技术池
01-17 735
不用太关心这些，原理是一样的。4  grpc、oauth2、openssl、双向认证、单向认证等专栏文章目录。先制作根证书，通过根证书去颁发客户端证书，服务器端证书，peer证书。5.2、如果每次命令行都写证书，API地址的话，太长了，如何简化呢？从而，在通过etcdctl操作etcd集群时，可以省略证书等相关参数。上面命令没有报错，反馈了正确的信息，说明，设置的环境变量生效了。2.4、制作Peer证书(集群成员之间进行传递时，用到的证书)主要涉及到三类证书： (就是创建一些证书，用在不同的地方)
利用gRPC构建Python微服务
老孙正经胡说
01-20 312
微服务架构目前仍然是一种主要的开发方式，笔者从2010年开始接触OpenStack，对OpenStack架构略有了解，于是在后期的产品研发中，沿用这一框架。但是随着项目的进行，也逐步发现了该框架中在实际应用中的缺陷，以及入门成本比较陡峭的问题。所以想结合gRPC思路，来分析一下是否有对现有框架优化的可能性。 本文大部分内容出自：https://realpython.com/python-microservices-grpc/，结合了笔者个人经验进行了整理，并非完全的翻译。国内很多网站翻译的版本并非完整版，
grpc的使用
qq_52395816的博客
12-20 1412
GRPC是谷歌开源的一个可以跨语言RPC的一个框架，可以实现跨语言远程调用
基于grpc从零开始搭建一个准生产分布式应用(4) - 01- proto详解
编程是一门实践技术
08-14 189
基于grpc、springboot、mybatis、mapstruct、mysql、proto框架集成一个准生产环境的微服务开发框架，是从真实生产环境中多次迭代后抽取后并加以改进。可稍加修改直接用于生产。
grpc使用
copymaster
11-05 581
使用grpc和protobuf实现rpc通信的例子 创建工程 mkdir grpc_test cd grpc_test go mod init //使用github的grpc替换gp的grpc go mod edit -replace=google.golang.org/grpc=github.com/grpc/grpc-go@latest go mod edit -replace=gola...
Grpc类型
zhanglong_longlong的专栏
12-16 4406
gRPC使用Protobuf作为其接口定义语言（IDL）。Protobuf IDL是一种语言无关的格式，用于指定gRPC服务发送和接收的消息。Protobuf消息在.proto文件中定义。本文档介绍了Protobuf概念如何映射到.NET。 Protobuf讯息 消息是Protobuf中的主要数据传输对象。它们在概念上类似于.NET类。 ProtoBuf复制 syntax = "proto3"; option csharp_namespace = "Contoso.Messages"; .
gRPC(Python)总结+踩坑记录
weixin_43405649的博客
06-17 1588
  总结一下在使用gRPC的过程中踩过的那些坑， 一定要仔细看官方文档！！！ 参考文档： Language Guide (proto3) Python Generated Code1.前言   出于项目需要，使用Python对gRPC进行二次开发。以前从没有接触过相关的概念，对于RPC、xml、json的了解也只限于听过名字的程度。初步接触gRPC的推荐阅读资源：     gRPC官方(基本上所有资料都在这里，但全英文和一些专有名词看得我头疼)     Protobuf3语言指南（中文翻译版）     gR
java高可用grpc_gRPC编码初探（java）
weixin_36198673的博客
01-13 294
//Generated by the protocol buffer compiler. DO NOT EDIT!//source: AccountQry.protopackagecom.mzsg.demo.grpc.qryaccount;public final classQryAccountProto {privateQryAccountProto() {}public static voi...
.netcore grpc的proto文件字段详解
qq_31975127的博客
08-16 1046
grpc的接口传输参数都是根据.proto文件约定的字段格式进行传输的grpc提供了多种类型字段；主要包括标量值类型（基础类型）、日期时间、可为null类型、字节、列表、字典、Any类型（任意类型）、Oneof等字段严格规范，是一种强类型文件协议标量值类型日期时间可为null类型字节列表字典Any类型Oneof：一种语言特性，可以通过该特性进行对象切换处理；使用oneof指定可能返回 A对象或B对象 的响应消息定义通用消息实体根据不同的类型创建对应的案例实体。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值