使用Spring Boot+gRPC构建微服务并部署到Istio

Istio 使用Spring Boot + GRPC构建部署微服务 作为和云原生技术的忠实拥护者,我却一直没有开发过Service Mesh的应用。正好最近受够了Spring Cloud的“折磨”,对Kubernetes也可以熟练使用了,而且网上几乎没有Spring Boot微服务部署到Istio的案例,我就开始考虑用Spring Boot写个微服务的Demo并且部署到Istio。项目本身不复杂,就是发送一个字符串并且返回一个字符串的最简单的Demo。 阅读详情

作为Service Mesh和云原生技术的忠实拥护者,我却一直没有开发过Service Mesh的应用。正好最近受够了Spring Cloud的“折磨”,对Kubernetes也可以熟练使用了,而且网上几乎没有Spring Boot微服务部署到Istio的案例,我就开始考虑用Spring Boot写个微服务的Demo并且部署到Istio。项目本身不复杂,就是发送一个字符串并且返回一个字符串的最简单的Demo。

 

题外话:我本来是想用Spring MVC写的——因为周围有的同学不相信Spring MVC也可以开发微服务,但是Spring MVC的各种配置和依赖问题把我整的想吐,为了少掉几根头发,还是用了方便好用的Spring Boot。

为什么要用Istio?

目前,对于Java技术栈来说,构建微服务的最佳选择是Spring Boot而Spring Boot一般搭配目前落地案例很多的微服务框架Spring Cloud来使用。

Spring Cloud看似很完美,但是在实际上手开发后,很容易就会发现Spring Cloud存在以下比较严重的问题:

  • 服务治理相关的逻辑存在于Spring Cloud Netflix等SDK中,与业务代码紧密耦合。

  • SDK对业务代码侵入太大,SDK发生升级且无法向下兼容时,业务代码必须做出改变以适配SDK的升级——即使业务逻辑并没有发生任何变化。

  • 各种组件令人眼花缭乱,质量也参差不齐,学习成本太高,且组件之间代码很难完全复用,仅仅为了实现治理逻辑而学习SDK也并不是很好的选择。

  • 绑定于Java技术栈,虽然可以接入其他语言但要手动实现服务治理相关的逻辑,不符合微服务“可以用多种语言进行开发”的原则。

  • Spring Cloud仅仅是一个开发框架,没有实现微服务所必须的服务调度、资源分配等功能,这些需求要借助Kubernetes等平台来完成。但Spring Cloud与Kubernetes功能上有重合,且部分功能也存在冲突,二者很难完美配合。

替代Spring Cloud的选择有没有呢?有!它就是Istio。

Istio彻底把治理逻辑从业务代码中剥离出来,成为了独立的进程(Sidecar)。部署时两者部署在一起,在一个Pod里共同运行,业务代码完全感知不到Sidecar的存在。这就实现了治理逻辑对业务代码的零侵入——实际上不仅是代码没有侵入,在运行时两者也没有任何的耦合。这使得不同的微服务完全可以使用不同语言、不同技术栈来开发,也不用担心服务治理问题,可以说这是一种很优雅的解决方案了。

所以,“为什么要使用Istio”这个问题也就迎刃而解了——因为Istio解决了传统微服务诸如业务逻辑与服务治理逻辑耦合、不能很好地实现跨语言等痛点,而且非常容易使用。只要会用Kubernetes,学习Istio的使用一点都不困难。

为什么要使用gRPC作为通信框架?

在微服务架构中,服务之间的通信是一个比较大的问题,一般采用RPC或者RESTful API来实现。

Spring Boot可以使用RestTemplate调用远程服务,但这种方式不直观,代码也比较复杂,进行跨语言通信也是个比较大的问题;而gRPC相比Dubbo等常见的Java RPC框架更加轻量,使用起来也很方便,代码可读性高,并且与Istio和Kubernetes可以很好地进行整合,在Protobuf和HTTP2的加持下性能也还不错,所以这次选择了gRPC来解决Spring Boot微服务间通信的问题。并且,虽然gRPC没有服务发现、负载均衡等能力,但是Istio在这方面就非常强大,两者形成了完美的互补关系。

由于考虑到各种grpc-spring-boot-starter可能会对Spring Boot与Istio的整合产生不可知的副作用,所以这一次我没有用任何的grpc-spring-boot-starter,而是直接手写了gRPC与Spring Boot的整合。不想借助第三方框架整合gRPC和Spring Boot的可以简单参考一下我的实现。

编写业务代码

首先使用Spring Initializr建立父级项目spring-boot-istio,并引入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 https://maven.apache.org/xsd/maven-4.0.0.xsd">    <modelVersion>4.0.0</modelVersion>    <modules>        <module>spring-boot-istio-api</module>        <module>spring-boot-istio-server</module>        <module>spring-boot-istio-client</module>    </modules>    <parent>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-parent</artifactId>        <version>2.2.6.RELEASE</version>        <relativePath/>     </parent>    <groupId>site.wendev</groupId>    <artifactId>spring-boot-istio</artifactId>    <version>0.0.1-SNAPSHOT</version>    <name>spring-boot-istio</name>    <description>Demo project for Spring Boot With Istio.</description>    <packaging>pom</packaging>
    <properties>        <java.version>1.8</java.version>    </properties>
    <dependencyManagement>        <dependencies>            <dependency>                <groupId>io.grpc</groupId>                <artifactId>grpc-all</artifactId>                <version>1.28.1</version>            </dependency>        </dependencies>    </dependencyManagement></project>
 

然后建立公共依赖模块spring-boot-istio-api,pom文件如下,主要就是gRPC的一些依赖:

<?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">    <parent>        <artifactId>spring-boot-istio</artifactId>        <groupId>site.wendev</groupId>        <version>0.0.1-SNAPSHOT</version>    </parent>    <modelVersion>4.0.0</modelVersion>
    <artifactId>spring-boot-istio-api</artifactId>
    <dependencies>        <dependency>            <groupId>io.grpc</groupId>            <artifactId>grpc-all</artifactId>        </dependency>        <dependency>            <groupId>javax.annotation</groupId>            <artifactId>javax.annotation-api</artifactId>            <version>1.3.2</version>        </dependency>    </dependencies>
    <build>        <extensions>            <extension>                <groupId>kr.motd.maven</groupId>                <artifactId>os-maven-plugin</artifactId>                <version>1.6.2</version>            </extension>        </extensions>        <plugins>            <plugin>                <groupId>org.xolstice.maven.plugins</groupId>                <artifactId>protobuf-maven-plugin</artifactId>                <version>0.6.1</version>                <configuration>                    <protocArtifact>com.google.protobuf:protoc:3.11.3:exe:${os.detected.classifier}</protocArtifact>                    <pluginId>grpc-java</pluginId>                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.28.1:exe:${os.detected.classifier}</pluginArtifact>                    <protocExecutable>/Users/jiangwen/tools/protoc-3.11.3/bin/protoc</protocExecutable>                </configuration>                <executions>                    <execution>                        <goals>                            <goal>compile</goal>                            <goal>compile-custom</goal>                        </goals>                    </execution>                </executions>            </plugin>        </plugins>    </build></project>
 

建立src/main/proto文件夹,在此文件夹下建立hello.proto,定义服务间的接口如下:

syntax = "proto3";option java_package = "site.wendev.spring.boot.istio.api";option java_outer_classname = "HelloWorldService";package helloworld;service HelloWorld {    rpc SayHello (HelloRequest) returns (HelloResponse) {}}
message HelloRequest {    string name = 1;}message HelloResponse {    string message = 1;}
 

很简单,就是发送一个name返回一个带name的message。

然后生成服务端和客户端的代码,并且放到java文件夹下。这部分内容可以参考gRPC的官方文档。

有了API模块之后,就可以编写服务提供者(服务端)和服务消费者(客户端)了。这里我们重点看一下如何整合gRPC和Spring Boot。

服务端

业务代码非常简单:

/** * 服务端业务逻辑实现 * * @author 江文 * @date 2020/4/12 2:49 下午 */@Slf4j@Componentpublic class HelloServiceImpl extends HelloWorldGrpc.HelloWorldImplBase {    @Override    public void sayHello(HelloWorldService.HelloRequest request,                         StreamObserver<HelloWorldService.HelloResponse> responseObserver) {        // 根据请求对象建立响应对象,返回响应信息        HelloWorldService.HelloResponse response = HelloWorldService.HelloResponse                .newBuilder()                .setMessage(String.format("Hello, %s. This message comes from gRPC.", request.getName()))                .build();        responseObserver.onNext(response);        responseObserver.onCompleted();        log.info("Client Message Received:[{}]", request.getName());    }}
 

光有业务代码还不行,我们还需要在应用启动时把gRPC Server也给一起启动起来。首先写一下Server端的启动、关闭等逻辑:

/** * gRPC Server的配置——启动、关闭等 * 需要使用<code>@Component</code>注解注册为一个Spring Bean * * @author 江文 * @date 2020/4/12 2:56 下午 */@Slf4j@Componentpublic class GrpcServerConfiguration {    @Autowired    HelloServiceImpl service;    /** 注入配置文件中的端口信息 */    @Value("${grpc.server-port}")    private int port;    private Server server;    public void start() throws IOException {        // 构建服务端        log.info("Starting gRPC on port {}.", port);        server = ServerBuilder.forPort(port).addService(service).build().start();        log.info("gRPC server started, listening on {}.", port);        // 添加服务端关闭的逻辑        Runtime.getRuntime().addShutdownHook(new Thread(() -> {            log.info("Shutting down gRPC server.");            GrpcServerConfiguration.this.stop();            log.info("gRPC server shut down successfully.");        }));    }    private void stop() {        if (server != null) {            // 关闭服务端            server.shutdown();        }    }    public void block() throws InterruptedException {        if (server != null) {            // 服务端启动后直到应用关闭都处于阻塞状态,方便接收请求            server.awaitTermination();        }    }}
 

定义好gRPC的启动、停止等逻辑后,就可以使用CommandLineRunner把它加入到Spring Boot的启动中去了:

/** * 加入gRPC Server的启动、停止等逻辑到Spring Boot的生命周期中 * * @author 江文 * @date 2020/4/12 3:10 下午 */@Componentpublic class GrpcCommandLineRunner implements CommandLineRunner {    @Autowired    GrpcServerConfiguration configuration;    @Override    public void run(String... args) throws Exception {        configuration.start();        configuration.block();    }}
 

之所以要把gRPC的逻辑注册成Spring Bean,就是因为在这里要获取到它的实例并进行相应的操作。

这样,在启动Spring Boot时,由于CommandLineRunner的存在,gRPC服务端也就可以一同启动了。

客户端

业务代码同样非常简单:

/** * 客户端业务逻辑实现 * * @author 江文 * @date 2020/4/12 3:26 下午 */@RestController@Slf4jpublic class HelloController {    @Autowired    GrpcClientConfiguration configuration;    @GetMapping("/hello")    public String hello(@RequestParam(name = "name", defaultValue = "JiangWen", required = false) String name) {        // 构建一个请求        HelloWorldService.HelloRequest request = HelloWorldService.HelloRequest                .newBuilder()                .setName(name)                .build();        // 使用stub发送请求至服务端        HelloWorldService.HelloResponse response = configuration.getStub().sayHello(request);        log.info("Server response received: [{}]", response.getMessage());        return response.getMessage();    }}
 

在启动客户端时,我们需要打开gRPC的客户端,并获取到channel和stub以进行RPC通信,来看看gRPC客户端的实现逻辑:

/** * gRPC Client的配置——启动、建立channel、获取stub、关闭等 * 需要注册为Spring Bean * * @author 江文 * @date 2020/4/12 3:27 下午 */@Slf4j@Componentpublic class GrpcClientConfiguration {    /** gRPC Server的地址 */    @Value("${server-host}")    private String host;    /** gRPC Server的端口 */    @Value("${server-port}")    private int port;    private ManagedChannel channel;    private HelloWorldGrpc.HelloWorldBlockingStub stub;    public void start() {        // 开启channel        channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();        // 通过channel获取到服务端的stub        stub = HelloWorldGrpc.newBlockingStub(channel);        log.info("gRPC client started, server address: {}:{}", host, port);    }    public void shutdown() throws InterruptedException {        // 调用shutdown方法后等待1秒关闭channel        channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);        log.info("gRPC client shut down successfully.");    }    public HelloWorldGrpc.HelloWorldBlockingStub getStub() {        return this.stub;    }}
 

比服务端要简单一些。

最后,仍然需要一个CommandLineRunner把这些启动逻辑加入到Spring Boot的启动过程中:

/** * 加入gRPC Client的启动、停止等逻辑到Spring Boot生命周期中 * * @author 江文 * @date 2020/4/12 3:36 下午 */@Component@Slf4jpublic class GrpcClientCommandLineRunner implements CommandLineRunner {    @Autowired    GrpcClientConfiguration configuration;    @Override    public void run(String... args) {        // 开启gRPC客户端        configuration.start();                // 添加客户端关闭的逻辑        Runtime.getRuntime().addShutdownHook(new Thread(() -> {            try {                configuration.shutdown();            } catch (InterruptedException e) {                e.printStackTrace();            }        }));    }}
 

编写Dockerfile

业务代码跑通之后,就可以制作Docker镜像,准备部署到Istio中去了。

在开始编写Dockerfile之前,先改动一下客户端的配置文件:

server:  port: 19090spring:  application:    name: spring-boot-istio-clientserver-host: ${server-host}server-port: ${server-port}
 

接下来编写Dockerfile:

服务端:

FROM openjdk:8u121-jdkRUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \  && echo 'Asia/Shanghai' >/etc/timezoneADD /target/spring-boot-istio-server-0.0.1-SNAPSHOT.jar /ENV SERVER_PORT="18080"ENTRYPOINT java -jar /spring-boot-istio-server-0.0.1-SNAPSHOT.jar
 

主要是规定服务端应用的端口为18080,并且在容器启动时让服务端也一起启动。

客户端:

FROM openjdk:8u121-jdkRUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \  && echo 'Asia/Shanghai' >/etc/timezoneADD /target/spring-boot-istio-client-0.0.1-SNAPSHOT.jar /ENV GRPC_SERVER_HOST="spring-boot-istio-server"ENV GRPC_SERVER_PORT="18888"ENTRYPOINT java -jar /spring-boot-istio-client-0.0.1-SNAPSHOT.jar \ --server-host=$GRPC_SERVER_HOST \ --server-port=$GRPC_SERVER_PORT
 

可以看到这里添加了启动参数,配合前面的配置,当这个镜像部署到Kubernetes集群时,就可以在Kubernetes的配合之下通过服务名找到服务端了。

同时,服务端和客户端的pom文件中添加:

    <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                <artifactId>spring-boot-maven-plugin</artifactId>                <configuration>                    <executable>true</executable>                </configuration>            </plugin>            <plugin>                <groupId>com.spotify</groupId>                <artifactId>dockerfile-maven-plugin</artifactId>                <version>1.4.13</version>                <dependencies>                    <dependency>                        <groupId>javax.activation</groupId>                        <artifactId>activation</artifactId>                        <version>1.1</version>                    </dependency>                </dependencies>                <executions>                    <execution>                        <id>default</id>                        <goals>                            <goal>build</goal>                            <goal>push</goal>                        </goals>                    </execution>                </executions>                <configuration>                    <repository>wendev-docker.pkg.coding.net/develop/docker/${project.artifactId}                    </repository>                    <tag>${project.version}</tag>                    <buildArgs>                        <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>                    </buildArgs>                </configuration>            </plugin>        </plugins>    </build>
 

这样执行mvn clean package时就可以同时把docker镜像构建出来了。

编写部署文件

有了镜像之后,就可以写部署文件了:

服务端:

apiVersion: v1kind: Servicemetadata:  name: spring-boot-istio-serverspec:  type: ClusterIP  ports:    - name: http      port: 18080      targetPort: 18080    - name: grpc      port: 18888      targetPort: 18888  selector:    app: spring-boot-istio-server---apiVersion: apps/v1kind: Deploymentmetadata:  name: spring-boot-istio-serverspec:  replicas: 1  selector:    matchLabels:      app: spring-boot-istio-server  template:    metadata:      labels:        app: spring-boot-istio-server    spec:      containers:        - name: spring-boot-istio-server          image: wendev-docker.pkg.coding.net/develop/docker/spring-boot-istio-server:0.0.1-SNAPSHOT          imagePullPolicy: Always          tty: true          ports:            - name: http              protocol: TCP              containerPort: 18080            - name: grpc              protocol: TCP              containerPort: 18888
 

主要是暴露服务端的端口:18080和gRPC Server的端口18888,以便可以从Pod外部访问服务端。

客户端:

apiVersion: v1kind: Servicemetadata:  name: spring-boot-istio-clientspec:  type: ClusterIP  ports:    - name: http      port: 19090      targetPort: 19090  selector:    app: spring-boot-istio-client---apiVersion: apps/v1kind: Deploymentmetadata:  name: spring-boot-istio-clientspec:  replicas: 1  selector:    matchLabels:      app: spring-boot-istio-client  template:    metadata:      labels:        app: spring-boot-istio-client    spec:      containers:        - name: spring-boot-istio-client          image: wendev-docker.pkg.coding.net/develop/docker/spring-boot-istio-client:0.0.1-SNAPSHOT          imagePullPolicy: Always          tty: true          ports:            - name: http              protocol: TCP              containerPort: 19090
 

主要是暴露客户端的端口19090,以便访问客户端并调用服务端。

如果想先试试把它们部署到k8s可不可以正常访问,可以这样配置Ingress:

apiVersion: networking.k8s.io/v1beta1kind: Ingressmetadata:  name: nginx-web  annotations:    kubernetes.io/ingress.class: "nginx"    nginx.ingress.kubernetes.io/use-reges: "true"    nginx.ingress.kubernetes.io/proxy-connect-timeout: "600"    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"    nginx.ingress.kubernetes.io/proxy-body-size: "10m"    nginx.ingress.kubernetes.io/rewrite-target: /spec:  rules:    - host: dev.wendev.site      http:        paths:          - path: /            backend:              serviceName: spring-boot-istio-client              servicePort: 19090
 

Istio的网关配置文件与k8s不大一样:

apiVersion: networking.istio.io/v1alpha3kind: Gatewaymetadata:  name: spring-boot-istio-gatewayspec:  selector:    istio: ingressgateway  servers:    - port:        number: 80        name: http        protocol: HTTP      hosts:        - "*"---apiVersion: networking.istio.io/v1alpha3kind: VirtualServicemetadata:  name: spring-boot-istiospec:  hosts:    - "*"  gateways:    - spring-boot-istio-gateway  http:    - match:        - uri:            exact: /hello      route:        - destination:            host: spring-boot-istio-client            port:              number: 19090
 

主要就是暴露/hello这个路径,并且指定对应的服务和端口。

部署应用到Istio

首先搭建k8s集群并且安装istio。我使用的k8s版本是1.16.0,Istio版本是最新的1.6.0-alpha.1,使用istioctl命令安装Istio。建议跑通官方的bookinfo示例之后再来部署本项目。

注:以下命令都是在开启了自动注入Sidecar的前提下运行的

我是在虚拟机中运行的k8s,所以istio-ingressgateway没有外部ip:

$ kubectl get svc istio-ingressgateway -n istio-systemNAME                   TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                                                                                                                                      AGEistio-ingressgateway   NodePort   10.97.158.232   <none>        15020:30388/TCP,80:31690/TCP,443:31493/TCP,15029:32182/TCP,15030:31724/TCP,15031:30887/TCP,15032:30369/TCP,31400:31122/TCP,15443:31545/TCP   26h
 

所以,需要设置IP和端口,以NodePort的方式访问gateway:

export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')export SECURE_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="https")].nodePort}')export INGRESS_HOST=127.0.0.1export GATEWAY_URL=$INGRESS_HOST:$INGRESS_PORT
 

这样就可以了。

接下来部署服务:

$ kubectl apply -f spring-boot-istio-server.yml$ kubectl apply -f spring-boot-istio-client.yml$ kubectl apply -f istio-gateway.yml
 

必须要等到两个pod全部变为Running而且Ready变为2/2才算部署完成。

接下来就可以通过

 
curl -s http://${GATEWAY_URL}/hello
 

访问到服务了。如果成功返回了Hello, JiangWen. This message comes from gRPC.的结果,没有出错则说明部署完成。

本项目的所有代码都上传到了GitHub,地址: https://github.com/WenDev/spring-boot-istio-demo

Spring Boot微服务架构(七):服务间通信方式有哪些? 本文总结了SpringBoot微服务架构中常见的服务间通信方式,分为同步通信、异步通信、服务网格和其他方式。同步通信包括RESTful API(适合实时响应场景)和gRPC(适合高性能需求);异步通信涵盖消息队列(如Kafka/RabbitMQ)和事件驱动架构(适用于解耦场景);服务网格(如Istio)适合治理大规模微服务;其他方式如Feign客户端和Dubbo RPC框架。建议根据实时性、解耦需求等因素综合选择,通常需要混合多种通信方式以满足不同业务场景需求。 阅读详情

相关推荐

xmljava系统源码-spring-boot-istio-demo:使用SpringBoot+gRPC构建微服务并部署到Istio的示例项目

xml java系统源码 使用Spring Boot+gRPC构建微服务并部署到Istio 作为Service Mesh和云原生技术的忠实拥护者,我却一直没有开发过Service Mesh的应用。正好最近受够了Spring Cloud的“折磨”,对Kubernetes也可以熟练使用了,而且网上几乎没有Spring Boot微服务部署到Istio的案例,我就开始考虑用Spring Boot写个微服务的Demo并且部署到Istio。项目本身不复杂,就是发送一个字符串并且返回一个字符串的最简单的Demo。 题外话:我本来是想用Spring MVC写的——因为周围有的同学不相信Spring MVC也可以开发微服务,但是Spring MVC的各种配置和依赖问题把我整的想吐,为了少掉几根头发,还是用了方便好用的Spring Boot。 本项目的所有代码都上传到了GitHub,地址: 如果有帮助的话不要吝啬你的Star和Fork呀,非常感谢~ 为什么要用Istio? 目前,对于Java技术栈来说,构建微服务的最佳选择是Spring Boot而Spring Boot一般搭配目前落地案例很多的微服务框架

SpringBoot整合Grpc实现跨语言RPC通讯

什么是gRPC gRPC是谷歌开源的基于go语言的一个现代的开源高性能RPC框架,可以在任何环境中运行。它可以有效地连接数据中心内和跨数据中心的服务,并提供可插拔的支持,以实现负载平衡,跟踪,健康检查和身份验证。它还适用于分布式计算的最后一英里,用于将设备,移动应用程序和浏览器连接到后端服务。 简单的服务定义:使用Protocol Buffers定义您的服务,这是一个功能强大的二进制序列化工具...

深度Java 2万+

KiCad 7.0 + 嘉立创打样:从原理图到实物,打造你的双LLCC68 LoRa串口透传板

本文详细介绍了使用KiCad 7.0设计双LLCC68 LoRa串口透传板的完整流程,从原理图设计到嘉立创打样。重点解析了AVR+LLCC68组合的优势、双模块布局的电磁兼容设计、SPI接口配置及射频走线技巧,并提供了实测数据和常见问题解决方案,帮助开发者高效实现物联网设备的低功耗远距离通信。

weixin_28693447的博客 263

SpringBoot整合高性能微服务框架 gRPC

如果不懂什么是RPC请点>>这里。1、简介在 gRPC 里,客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法,使得我们能够更容易地创建分布式应用和服务。gRPC 基于 HTTP/2 标准设计,带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等。这些特性使得其在移动设备上表现更好,更省电和节省空间占用。目前有非常多优秀的开源项目采用 gRPC 作为...

IT学习小镇 625

ArcGIS中标注(label)的使用技巧

标注是显示在地图上的文字信息,它是出图中不可或缺的重要元素。标注的样式丰富,并且放置位置灵活,因此带来了对标注控制的难度。例如地质图里的上下标,或是一些分式的标注,就必须使用代码编程来实现。这篇文章就主要结合几个实例来讨论一下标注的使用技巧,以及在ArcGIS软件中的实现。

2万+

CentOS 7 离线升级 OpenSSH 9.9p2 保姆级教程(含依赖包下载与常见报错解决)

本文提供了一份详尽的CentOS 7系统离线升级OpenSSH至9.9p2版本的完整教程。针对无外网环境,重点讲解了依赖包(尤其是OpenSSL 3.x)的离线下载与编译部署,并深入解决了编译过程中常见的“libcrypto.so缺失”等动态库链接错误。教程涵盖从环境准备、源码编译、服务配置到系统集成的全流程,最后还提供了关键的回滚方案与应急预案,是运维人员在内网环境中进行安全加固的实用指南。

weixin_29248313的博客 325

grpc Java demo与Springboot改造支持grpc通信

最近调研grpc的情况,发现grpc实际上还是HTTP2协议,实际上就是http2+proto传输。那么是否可以在现有的server支持呢,试了下,还真可以,但是笔者在返回数据时有个问题一直没有思路。

fenglllle的博客 2084

FPGA设计中的扇出约束实战:从XDC到代码优化的全流程解析

本文全面解析FPGA设计中扇出约束的重要性与应用,详细介绍了从XDC约束文件设置到HDL代码优化的全流程实战技巧。通过MAX_FANOUT约束控制信号负载,结合寄存器复制和物理优化策略,有效解决高扇出导致的时序违例和布线拥塞问题,提升设计性能和可靠性。

nept的博客 798

Spring Boot+gRPC构建微服务并部署到Istio(详细教程)

目前,对于Java技术栈来说,构建微服务的最佳选择是Spring Boot而Spring Boot一般搭配目前落地案例很多的微服务框架Spring Cloud来使用。Spring Cloud看似很完美,但是在实际上手开发后,很容易就会发现Spring Cloud存在以下比较严重的问题: 服务治理相关的逻辑存在于Spring Cloud Netflix等SDK中,与业务代码紧密耦合。 SDK对业务代码侵入太大,SDK发生升级且无法向下兼容时,业务代码必须做出改变以适配SDK的升级——即使业务逻辑并没有

2401_83384536的博客 1339

AFSim 2.9实战指南:从入门到精通的中文教程

本文是AFSim 2.9的实战中文教程,旨在帮助用户从零开始掌握这一先进的仿真框架。内容涵盖从环境安装、运行第一个“Hello World”仿真,到深入理解实体、组件、想定编辑器等核心概念,并进阶探讨动力学建模、传感器仿真与红蓝对抗想定构建。最后,指南还提供了效能分析与实战排错技巧,帮助用户将仿真结果转化为有价值的量化数据,适用于军事、航空航天等领域的复杂系统行为模拟研究。

weixin_29294395的博客 363

开源项目evo2安装教程

Evo 2 是一种先进的 DNA 语言模型,用于长上下文建模和设计。Evo 2 使用 StripedHyena 2 架构在单核苷酸分辨率下对 DNA 序列进行建模,上下文长度可达 100 万碱基对。Evo 2 使用 Savanna 进行预训练,并在 OpenGenome2 数据集上进行自回归训练,该数据集包含来自所有生命领域的 8.8 万亿个标记。

猿小白的博客 928

Spring 微服务架构(Spring Boot,Spring Cloud,高并发)

微服务架构是一种将应用拆分为多个独立、协作的小型服务的架构风格,与传统的单体架构相比具有更高扩展性和灵活性。Spring微服务是使用Spring框架构建微服务的完整解决方案,包含Spring Boot基础和Spring Cloud治理组件。其他主流微服务技术还包括Go语言的Go Micro、Node.js的NestJS以及跨语言的Kubernetes服务网格等。微服务架构虽然提高了系统弹性,但也带来了部署和运维的复杂性,需要根据项目规模权衡选择。

Hongwei_1990的博客 1340

Unity中语法糖带来的GC问题 ——那些看起来优雅、实际上在背后偷偷生垃圾的代码

*语法糖(Syntactic Sugar)**指的是编程语言中为了让代码更简洁、易读而提供的简便写法。比如C#中的foreachlambda表达式LINQ自动属性等。语法糖本身不是坏事,但在Unity等对GC敏感的环境下,要警惕语法糖带来的隐式内存分配。合理使用语法糖,关键场合用更“丑陋”但高效的写法,才能保证游戏流畅运行。下面我将更深入地分析Unity中语法糖导致GC的原理、具体场景、检测与优化技巧,并补充一些容易忽视的细节。

本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度,也有思维广度,无论你是开发者、创业者还是高校学子,都能在这里找到适合自己的成长之路! 520

实战|Service Mesh微服务架构实现服务间gRPC通信

大家好!我是"无敌码农"!在前面的文章<<干货|如何步入Service Mesh微服务架构时代>>中介绍了基于Kubernetes及Istio如何一...

无敌码农 1232

如何使用 Python 爬虫获取猫眼电影数据:电影评分与评论分析

随着互联网的快速发展,越来越多的人开始使用各种在线平台来了解电影信息,猫眼电影作为一个非常流行的在线电影票务平台,提供了详细的电影评分、评论和票房数据。本篇博客将详细介绍如何使用 Python 爬虫技术获取猫眼电影平台上的电影数据,重点关注电影评分和用户评论的爬取,分析其背后的数据处理和反爬虫技术。如果你对数据分析、电影评论分析等话题感兴趣,可以根据本文的示例进一步深入挖掘更多的数据,为决策提供支持,或为电影产业的相关研究提供有价值的分析依据。有些猫眼电影的页面数据是动态加载的,使用。

2201_76125261的博客 1623

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java微服务治理新纪元(Istio 1.22集成权威指南)

掌握Java微服务架构中的服务网格Istio 1.22集成,实现高可用、可观测与安全治理。涵盖流量控制、熔断策略、零信任安全及多语言支持,适用于云原生生产环境。一站式部署与调试指南,助力企业级服务治理升级,值得收藏。

LiteTrans的博客 607

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java面试进阶:Spring Boot、微服务与AI技术栈深度解析

在Java技术栈的面试中,Spring Boot的自动配置原理和微服务架构设计是核心考察点。自动配置通过spring.factories和@Conditional注解实现模块化加载,而微服务架构则强调业务能力优先的服务拆分原则。随着AI技术的普及,大厂开始关注Spring Boot与TensorFlow Serving的整合,以及分布式推理的性能优化。掌握这些技术不仅能提升面试通过率,更能应对实际工程中的复杂场景。本文结合热词“自动配置原理”和“分布式推理”,深入解析Java技术栈的最新面试趋势与实践技巧。

weixin_34054931的博客 338

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

快速了解Service Mesh微服务架构实现服务间gRPC通信

在前面的文章之中我们介绍了基于Kubernetes及Istio如何一步一步把Service Mesh微服务架构玩起来!在该文章中,我们演示了一个非常贴近实战的案例,这里回顾下该案例的结构,如下图所示: 该案例所演示的就是我们日常使用微服务架构开发时,服务间最普遍的通信场景。在Spring Cloud微服务体系中,服务间可以通过Fegin+Ribbon组合的方式,实现服务间负载均衡方式的Http接口调用;但在Service Mesh架构中,服务发现及负载均衡等治理逻辑已经由SideCar代理,如果还希望延.

417

Spring Boot 3.x微服务如何安全穿越Istio 1.20 GA门槛?(附2024 Q2生产环境灰度验证报告)

Spring Boot 3.x微服务平滑升级Istio 1.20的实战指南,涵盖Java微服务Istio 1.20适配教程、TLS双向认证配置、Sidecar注入优化及Q2生产灰度验证结果。适用于云原生迁移与安全合规场景,提升服务网格稳定性与可观测性,值得收藏。

LiteTrans的博客 417

【Java微服务架构进阶指南】:Istio 1.22服务网格集成实战全解析

掌握Java微服务架构中的服务网格Istio 1.22集成,解决多服务治理与通信难题。涵盖流量管理、安全认证与可观测性实现方法,适用于云原生场景。核心优势包括无缝对接Spring Cloud、自动化灰度发布与故障注入。实战配置详解,值得收藏。

StepLens的博客 865
上一篇: 重磅!Grafana 9 正式发布,更强大、更易用了!
下一篇: 一款神仙接私活低代码平台,牛到不行!
程序员职业指南
博客等级 码龄4年 2141粉丝 960原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值