spring-cloud-kubenetes 与 feign调用

已于 2022-05-12 19:52:52 修改
阅读量529 收藏 1
点赞数
分类专栏： k8s minikube docker 文章标签： 微服务 spring docker
于 2022-05-07 16:52:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38168657/article/details/124627251
版权
docker 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
k8s
5 篇文章 0 订阅
订阅专栏
minikube
2 篇文章 0 订阅
订阅专栏

目录

1、所需环境：

  • windows 安装 Ubuntu-18.04
  • docker
  • minikube

2、安装docker

  1. 安装yum-utils包（提供yum-config-manager 实用程序）并设置稳定的存储库。

    sudo yum install -y yum-utils
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

  2. 安装 Docker 引擎

    sudo yum install docker-ce docker-ce-cli containerd.io

  3. 启动 Docker

    sudo /etc/init.d/docker start # wsl2 启动

  4. 测试安装

    docker --version

  5. 通过运行hello-world 映像来验证 Docker 引擎是否已正确安装。

    sudo docker run hello-world

以上docker安装完成

3、安装minikube

  1. 更新包

    sudo apt-get update
sudo apt-get install apt-transport-https
sudo apt-get upgrade

  2. 安装Virtual Box（用来跑minikube）

    sudo apt install virtualbox virtualbox-ext-pack

  3. 下载minikube

    wget https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube-linux-amd64
sudo mv minikube-linux-amd64 /usr/local/bin/minikube

  4. 验证minikube的版本

    minikube version

    root@localhost:~$ minikube version
minikube version: v1.25.2
commit: 362d5fdc0a3dbee389b3d3f1034e8023e72bd3a7
root@localhost:~$

  5. 在Ubuntu上安装 kubectl

    1. 使用命令行下载安装包
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
    2. 安装kubectl
      sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
    3. 测试安装 kubectl version --client 或使用 kubectl version -o json 验证安装是否正确
      kubectl version --client

      root@localhost:~$ kubectl version --client
WARNING: This version information is deprecated and will be replaced with the output from kubectl version --short.  Use --output=yaml|json to get the full version.
Client Version: version.Info{Major:"1", Minor:"24", GitVersion:"v1.24.0", GitCommit:"4ce5a8954017644c5420bae81d72b09b735c21f0", GitTreeState:"clean", BuildDate:"2022-05-03T13:46:05Z", GoVersion:"go1.18.1", Compiler:"gc", Platform:"linux/amd64"}
Kustomize Version: v4.5.4
root@localhost:~$

      root@localhost:~$ kubectl version -o json
{
  "clientVersion": {
    "major": "1",
    "minor": "24",
    "gitVersion": "v1.24.0",
    "gitCommit": "4ce5a8954017644c5420bae81d72b09b735c21f0",
    "gitTreeState": "clean",
    "buildDate": "2022-05-03T13:46:05Z",
    "goVersion": "go1.18.1",
    "compiler": "gc",
    "platform": "linux/amd64"
  },
  "kustomizeVersion": "v4.5.4",
  "serverVersion": {
    "major": "1",
    "minor": "23",
    "gitVersion": "v1.23.3",
    "gitCommit": "816c97ab8cff8a1c72eccca1026f7820e93e0d25",
    "gitTreeState": "clean",
    "buildDate": "2022-01-25T21:19:12Z",
    "goVersion": "go1.17.6",
    "compiler": "gc",
    "platform": "linux/amd64"
  }
}
root@localhost:~$

以上minikube安装完成

4、新建服务发现工程

  • 环境信息：
    1、minikube
    2、java 1.8
    3、maven 3.6
    4、spring-cloud-kubernetes：1.0.1RELEASE

  • 开发应用
    基于maven创建一个springboot应用，名为spring-cloud-k8s-discovery-demo；

  1. pom文件中依赖了spring-cloud-kubernetes的以下两个库，后面才能使用spring-cloud-kubernetes的服务；

    <dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-kubernetes-core</artifactId>
	<version>1.0.1.RELEASE</version>
</dependency>

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-kubernetes-discovery</artifactId>
	<version>1.0.1.RELEASE</version>
</dependency>

  2. 创建DiscoveryController.java类：

    package com.example.springcloudk8sdiscoverydemo.controller;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.text.SimpleDateFormat;
import java.util.Date;

@RestController
public class DiscoveryController {

    @Autowired
    private DiscoveryClient discoveryClient;

    /**
     * 探针检查响应类
     *
     * @return
     */
    @RequestMapping("/health")
    public String health() {
        return "health";
    }

    /**
     * 返回远程调用的结果
     *
     * @return
     */
    @RequestMapping("/getservicedetail")
    public String getservicedetail(
            @RequestParam(value = "servicename", defaultValue = "") String servicename) {
        return "Service [" + servicename + "]'s instance list : " + JSON.toJSONString(discoveryClient.getInstances(servicename));
    }

    /**
     * 返回发现的所有服务
     *
     * @return
     */
    @RequestMapping("/services")
    public String services() {
        return this.discoveryClient.getServices().toString()
                + ", "
                + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }
}

  3. 启动类：

    package com.example.springcloudk8sdiscoverydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringCloudK8sDiscoveryDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudK8sDiscoveryDemoApplication.class, args);
    }
}

  4. 编写 application.properties

    spring.application.name=spring-cloud-k8s-discovery-demo
server.port=8088

  5. 总结：

    1. DiscoveryClient是个接口，对应的实现类是哪个?

      <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-kubernetes-discovery</artifactId>
  <version>1.0.1.RELEASE</version>
</dependency>

      在这里插入图片描述
      spring容器启动时，会寻找classpath下所有spring.factories文件(包括jar文件中的)，spring.factories中配置的所有类都会实例化，我们在开发springboot时常用到的XXX-starter.jar就用到了这个技术，效果是一旦依赖了某个starter.jar很多功能就在spring初始化时候自动执行了

    2. discoveryClient.getServices()方法取得了kubernetes的service信息，这背后的机制是什么？java应用是怎样取得所在kubernetes的服务信息的？

      @RequestMapping("/services")
    public String services() {
        return this.discoveryClient.getServices().toString()
                + ", "
                + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }

      discoveryClient对应的类是spring-cloud-kubernetes项目的KubernetesDiscoveryClient.java

      	public List<String> getServices() {
        String spelExpression = this.properties.getFilter();
        Predicate filteredServices;
        if (spelExpression != null && !spelExpression.isEmpty()) {
            Expression filterExpr = this.parser.parseExpression(spelExpression);
            filteredServices = (instance) -> {
                Boolean include = (Boolean)filterExpr.getValue(this.evalCtxt, instance, Boolean.class);
                return include == null ? false : include;
            };
        } else {
            filteredServices = (instance) -> {
                return true;
            };
        }

        return this.getServices(filteredServices);
    }

    public List<String> getServices(Predicate<Service> filter) {
        return (List)((ServiceList)((FilterWatchListDeletable)this.kubernetesClientServicesFunction.apply(this.client)).list()).getItems().stream().filter(filter).map((s) -> {
            return s.getMetadata().getName();
        }).collect(Collectors.toList());
    }

      这段代码的关键在于this.kubernetesClientServicesFunction.apply(this.client).list()，先看KubernetesClientServicesFunction实例的初始化过程，在KubernetesDiscoveryClientAutoConfiguration类中：

      @Bean
public KubernetesClientServicesFunction servicesFunction(
			KubernetesDiscoveryProperties properties) {
  if (properties.getServiceLabels().isEmpty()) {
    return KubernetesClient::services;
  }

  return (client) -> client.services().withLabels(properties.getServiceLabels());
}

      KubernetesClientServicesFunction是个lambda表达式，用于KubernetesClient的时候，返回KubernetesClient.services()的结果，如果指定了标签过滤，就用指定的标签来做过滤（也就是kubernetes中的标签选择器的效果）
      因此，数据来源其实就是上面的this.client，调用其services方法的返回结果；
      最终是调用okhttp的newCall方法向kubernetes的API Server发起http请求，获取service资源的数据列表；

5、部署工程

  1. 官方demo使用插件fabric8-maven-plugin来构建镜像并部署到minikube环境，我这边可能是环境问题没有部署成功，我是将jar包打成镜后部署到minikube；

    1. 编写dockerfile并执行

      FROM openjdk:8u242-jre-slim
WORKDIR /app/spring-cloud-k8s-discovery-demo
COPY spring-cloud-k8s-discovery-demo-0.0.1-SNAPSHOT.jar /app/spring-cloud-k8s-discovery-demo
RUN echo 'Asia/Shanghai' >/etc/timezone
EXPOSE 8080
CMD ["java", "-jar", "spring-cloud-k8s-discovery-demo-0.0.1-SNAPSHOT.jar"]

      docker build -f spring-cloud-k8s.Dockerfile .

    2. 镜像打包完成并推送至docker hub

      docker push zwzhang2022/spring-cloud-k8s:1.0

    3. 编写kubenetes.yaml

      apiVersion: v1
kind: Service
metadata:
  labels:
    app: spring-cloud-k8s-discovery-demo
  name: spring-cloud-k8s-discovery-demo
  namespace: spring-cloud-k8s-demo
spec:
  type: NodePort
  ports:
    - port: 8088 #服务端口
      protocol: TCP
      targetPort: 8088
  selector:
    app: spring-cloud-k8s-discovery-demo
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-cloud-k8s-discovery-demo-deployment
  namespace: spring-cloud-k8s-demo
spec:
  selector:
    matchLabels:
      app: spring-cloud-k8s-discovery-demo
  replicas: 1
  template:
    metadata:
      labels:
        app: spring-cloud-k8s-discovery-demo
    spec:
      containers:
        - name: spring-cloud-k8s-discovery-demo
          image: zwzhang2022/spring-cloud-k8s-discovery-demo:2.0
          imagePullPolicy: Always
          ports:
            - containerPort: 8088

    4. 创建命名空间并查看

      kubectl create namespace spring-cloud-k8s-demo
kubectl get namespace

    5. 创建并查看

      kubectl  apply -f kubenetes.yaml
kubectl -n kubenetes-demo get pods
kubectl -n spring-cloud-k8s-demo describe pod <PodName> #查看pod详细信息

    6. 进入容器

      kubectl -n spring-cloud-k8s-demo exec -it spring-cloud-k8s-discovery-demo-deployment-8499cbdfc-ddsvs -c spring-cloud-k8s-discovery-demo -- sh

    7. 进入容器后 curl 调用接口

      /app # curl http://localhost:8080/health
health

/app # curl http://localhost:8080/services
[spring-cloud-k8s-configmap-demo, spring-cloud-k8s-discovery-demo], 2022-05-10 18:28:54

/app # curl http://localhost:8080/getservicedetail?servicename=spring-cloud-k8s-discovery-demo
Service [spring-cloud-k8s-discovery-demo]'s instance list : [{"host":"172.17.0.3","instanceId":"d63e413d-a4a3-4bf7-a778-734d7edb3daa","metadata":{"app":"spring-cloud-k8s-discovery-demo","kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"spring-cloud-k8s-discovery-demo\"},\"name\":\"spring-cloud-k8s-discovery-demo\",\"namespace\":\"spring-cloud-k8s-demo\"},\"spec\":{\"ports\":[{\"port\":8088,\"protocol\":\"TCP\",\"targetPort\":8088}],\"selector\":{\"app\":\"spring-cloud-k8s-discovery-demo\"},\"type\":\"NodePort\"}}\n"},"port":8088,"scheme":"http://","secure":false,"serviceId":"spring-cloud-k8s-discovery-demo","uri":"http://172.17.0.3:8088"}]

以上服务发现部署完成

6、k8s集成feign

  1. 引入依赖库

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.7.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>spring-cloud-k8s-feign-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-cloud-k8s-feign-demo</name>
<description>spring-cloud-k8s-feign-demo</description>
<properties>
    <java.version>1.8</java.version>
    <springcloud.kubernetes.version>1.0.1.RELEASE</springcloud.kubernetes.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-kubernetes-core</artifactId>
        <version>${springcloud.kubernetes.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-kubernetes-discovery</artifactId>
        <version>${springcloud.kubernetes.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-kubernetes-ribbon</artifactId>
        <version>${springcloud.kubernetes.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-commons</artifactId>
    </dependency>
    <dependency>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        <groupId>org.springframework.cloud</groupId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        <version>2.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
        <groupId>org.springframework.cloud</groupId>
    </dependency>


    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.SR3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

  2. 创建application.yml配置文件

    spring:
  application:
    name: spring-cloud-k8s-feign-demo

product-infra-service:
  ribbon:
    KubernetesNamespace: spring-cloud-k8s-demo

backend:
  ribbon:
    eureka:
      enabled: false
    client:
      enabled: true
    ServerListRefreshInterval: 5000

hystrix:
  command:
    BackendCall:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000
  threadpool:
    BackendCallThread:
      coreSize: 5
feign:
  hystrix:
    enabled: true
server:
  port: 8082

  3. 启动类代码

    package com.example.springcloudk8sfeigndemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.example.springcloudk8sfeigndemo")
public class SpringCloudK8sFeignDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudK8sFeignDemoApplication.class, args);
    }

}

  4. feign接口代码

    package com.example.springcloudk8sfeigndemo;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient(name = "spring-cloud-k8s-discovery-demo", fallback = TestClientFallback.class)
public interface TestClient {

    @RequestMapping("/services")
    String services();
}

  5. fallback类代码

    package com.example.springcloudk8sfeigndemo;

import org.springframework.stereotype.Component;

@Component
public class TestClientFallback implements TestClient {
    @Override
    public String services() {
        return "hystrix call back";
    }
}

  6. controller接口

    package com.example.springcloudk8sfeigndemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @Autowired
    private TestClient testClient;

    @GetMapping("test1")
    public String test1() {
        return testClient.services();
    }

}

  7. 部署到k8s验证 （kubenetes.yaml可以参考服务发现）

    /app # curl http://localhost:8082/test1
[spring-cloud-k8s-configmap-demo, spring-cloud-k8s-discovery-demo, spring-cloud-k8s-feign-demo], 2022-05-12 19:38:25
/app #
写bug的路上
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
k8s-feign-demo:spring-cloud-k8s 服务发现负载均衡交给k8s
05-13
k8s-feign-demo 服务发现demo skill stacks feign k8s-dns
spring-cloud-kubernetes-feign实战
qingdao666666的博客
08-23 765
关于spring-cloud-kubernetes spring-cloud-kubernetes是springcloud官方推出的开源项目，用于将Spring Cloud和Spring Boot应用运行在kubernetes环境，并且提供了通用的接口来调用kubernetes服务，主要提供了应用程序使用k8s本身功能：服务注册发现、客户端负载均衡、从Kubernetes ConfigMap和Secrets加载应用程序属性 。 ConfigMap或Secret更改时，重新加载应用程序属性。GitHub上官
k8s中使用Feign实现服务间调用
最新发布
很多时候犯错都是在不知情的情况下发生的
05-23 196
在spring cloud中服务之间的调用我们通常是通过Feign来完成的。Feign作为一个声明式WebService客户端，使用非常的简单，通过在我们的接口上添加注解，我们很容易就实现一个服务调用的客户端。使用注解也可以减少开发的代码量，可以说非常的方便。另外Feign内部也集成了Ribbon从而自动帮我们实现客户端的负载均衡，可以说是spring cloud微服务的必用组件。
ES启动器实现及应用间fegin调用fastJson数据解析时间类型转换bug修复
qq_34905631的博客
10-18 939
​     这个类是用来解决fastJson时间类型转换的序列化解析器，fastJson默认是不支持LocalDateTime、LocalDate类型直接转换为Date类型的，所以这个是使用fastJson的一个大坑，这个算是fastJson的一个bug，本来想给fastJsong官方提一个bug的，后面想想算了，这个坑也是坑的，官方解决不了，那只能自己解决了，自己改它的源码在自己项目中修复这个bug了。
Kubernetes 开发 SpringCloud (三)、使用 SpringCloud Feign 进行 SrpingCloud 服务间的通信
qingdao666666的博客
08-23 172
2019-07-25 17:21:02 文章目录 一、介绍 Feign 简介 Hystrix 简介 二、Kubernetes 中使用 Feign 进行服务间通信 三、Kubernetes 中项目使用 Feign 进行服务间通信示例 1、Feign 接口项目示例代码 2、服务提供者示例代码 3、服务消费者示例代码 4、构建 Docker 镜像 5、准备 Kubernetes 部署文件 6、将项目推送到 Kubernetes 7、测试接口 四、可配置参数 ..
Feign在K8s中的使用
罗小爬的技术宝书
10-12 8805
之前在SpringCloud中使用过@FeignClient的方式对服务进行调用，感觉使用起来还是很方便的，所以想要探索一下是否可以把@FeignClient用在K8s集群中进行服务间的调用； feign是一个声明式web服务调用的客户端，创建一个接口并加上注解就能使用Feign了（同时支持JAX-RS类型的注解，可插入式的编码和解码），Spring Cloud Feign组件为他加入了spri...
spring-cloud-user-feign.zip
02-20
在本项目"spring-cloud-user-feign.zip"中，我们探讨的是如何在Spring Cloud框架下实现服务间的调用，特别是利用Feign客户端进行微服务通信。这个压缩包包含了四个关键组件，分别是： 1. spring-cloud-gateways：这...
spring-cloud.zip
07-30
综上所述，这个"spring-cloud.zip"的Demo充分展示了Spring Cloud如何构建一个完整的微服务架构，通过集成各种组件，实现了服务注册、配置管理、容错保护、API管理和服务调用等功能，为现代云原生应用提供了坚实的...
Spring-cloud-eureka使用feign调用服务接口
08-26
Spring Cloud Eureka 使用 Feign 调用服务接口 Spring Cloud Eureka 是一种基于微服务架构的服务注册和发现机制，Feign 是一种声明式 RESTful 客户端实现框架。通过将二者结合使用，可以实现更加简洁、高效的微服务...
详解Spring-Cloud2.0之Feign调用远程服务指南
08-26
"详解Spring-Cloud2.0之Feign调用远程服务指南" Feign是简化Java HTTP客户端开发的工具，灵感来自于Retrofit、JAXRS-2.0和WebSocket。Feign的初衷是降低统一绑定Denominator到HTTP API的复杂度，不区分是否为...
spring-cloud-kubernetes-1.1.2.RELEASE.tar.gz
06-15
通过解压"spring-cloud-kubernetes-1.1.2.RELEASE"压缩包，你可以查看源码，了解其内部实现机制，深入学习如何在实际项目中充分利用SCK与Kubernetes的集成优势。 在实际应用中，理解并掌握Spring Cloud Kubernetes...
【Kubernetes】基于K8S & SpringCloud OpenFeign的一种微服务构建模式
懂幸福，爱生活
07-31 1965
在构建微服务之前，需要进行微服务框架选型，之前的微服务完全基于springcloud构建，而现在则需要基于云原生的方式来构建。
springboot+k8s+抛弃springcloud.eureka
m0_68064743的博客
04-24 2411
springboot开发微服务框架一般使用springcloud全家桶，而整个项目都是容器化的，通过k8s进行编排，而k8s自己也有服务发现机制，所以我们也可以抛弃springcloud里的eureka，而直接使用k8s自己的服务。 添加组件 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-rib
k8s上运行我们的springboot服务之——简单的架构思考
weiranaixi的博客
10-31 1679
综述 目前java后台开发人员不管面试还是真实的项目实战都离不开一个主题soa，微服务的技术实现主要有springcloud和dubbo（当然还有其他的一些rpc框架）。个人觉得rpc架构只是一种服务调用的实现，我们开发人员更应该去了解各个技术实现各个复杂的业务功能（例如：如果用分布式锁去实现秒杀），具体表现在开发人员的工作内容了解业务去用合理的sql语句解决问题，其他的接口和底层的服务，在架构上...
4.k8s部署微服务组件Feign
Leeyehong_self的专栏
02-28 1897
1. Feign概述 1.1是什么 官网解释： http://projects.spring.io/spring-cloud/spring-cloud.html#spring-cloud-feign Feign是一个声明式REST客户端。使用Feign能让编写Web Service客户端更加简单, 它的使用方法是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可...
SpringCloud微服务迁移至Kubernetes实践
热门推荐
嗡汤圆的博客
09-18 1万+
SpringCloud微服务迁移至Kubernetes实践 前言 原SpringCloud基础上的微服务已稳定运行近1年，遗留了一些问题不太好处理，如下： 客户端侧负载均衡在服务实例故障下线时候，不能及时发现，导致请求到故障实例地址造成请求错误，若增加请求重试配置，对于非幂等接口处理困难。 基于SpringCloud Config的配置中心有时候会有不及时刷新svn上的配置信息的情况（需要重新c...
spring-cloud-build 依赖
06-03
`spring-cloud-build` 是一个用于构建基于 Spring Cloud 的微服务的 Maven 插件。它提供了一系列的依赖，可以用于快速搭建基于 Spring Cloud 的微服务应用。这些依赖包括： - `spring-cloud-starter-config`：用于从 Spring Cloud Config Server 中获取配置信息的依赖。 - `spring-cloud-starter-netflix-eureka-client`：用于将微服务注册到 Eureka 服务注册中心的依赖。 - `spring-cloud-starter-netflix-hystrix-dashboard`：用于搭建 Hystrix Dashboard 的依赖。 - `spring-cloud-starter-openfeign`：用于构建基于 Feign 的声明式 REST 客户端的依赖。 - `spring-cloud-starter-sleuth`：用于跟踪和监控微服务之间的调用链路的依赖。 - `spring-cloud-starter-zipkin`：用于构建 Zipkin 分布式跟踪系统的依赖。 除了这些依赖之外，`spring-cloud-build` 还提供了一些插件，可以用于快速搭建和部署微服务应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

写bug的路上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值