因公众号更改推送规则，请点“在看”并加“星标”第一时间获取精彩技术分享

点击关注#互联网架构师公众号，领取架构师全套资料 都在这里d65ec75912342854efe93531e0a9a0a3.png

0、2T架构师学习资料干货分

上一篇：2T架构师学习资料干货分享

大家好，我是互联网架构师！

灰度发布, 也叫金丝雀发布。是指在黑与白之间，能够平滑过渡的一种发布方式。AB test就是一种灰度发布方式，让一部分用户继续用A，一部分用户开始用B，如果用户对B没有什么反对意见，那么逐步扩大范围，把所有用户都迁移到B上面来。

灰度发布可以保证整体系统的稳定，在初始灰度的时候就可以发现、调整问题，以保证其影响度，而我们平常所说的金丝雀部署也就是灰度发布的一种方式。

具体到服务器上，实际操作中还可以做更多控制，譬如说，给最初更新的10台服务器设置较低的权重、控制发送给这10台服务器的请求数，然后逐渐提高权重、增加请求数。一种平滑过渡的思路, 这个控制叫做“流量切分”。

组件版本说明

我们这项目已经练习了两年半了使用的版本不是很新，我这里的Demo也会使用这个版本，有感情了，使用新版本的朋友自己调整一下就行，实现思路是一样的只是这些框架源码可能会有变化。

  • spring-boot: 2.3.12.RELEASE

  • spring-cloud-dependencies: Hoxton.SR12

  • spring-cloud-alibaba-dependencies: 2.2.9.RELEASE

spring-cloud 对应版本关系图

https://blog.csdn.net/weixin_44606481/article/details/131726688

核心组件说明

  • 注册中心： Nacos

  • 网关： SpringCloudGateway

  • 负载均衡器： Ribbon （使用SpringCloudLoadBalancer实现也是类似的）

  • 服务间RPC调用： OpenFeign

灰度发布代码实现

要实现Spring Cloud项目灰度发布技术方案有很多，重点在于服务发现，怎么将灰度流量只请求到灰度服务，这里我们会使用Nacos作为注册中心和配置中心，核心就是利用Nacos的Metadata设置一个version值，在调用下游服务是通过version值来区分要调用那个版本，这里会省略一些流程，文章末尾提供了源码地址需要自提。

4c891a7abf71863567c178db30a97d80.png

代码设计结构

这个是demo项目，结构都按最简单的来。

spring-cloud-gray-example // 父工程
   kerwin-common // 项目公共模块
   kerwin-gateway // 微服务网关
   kerwin-order // 订单模块
      order-app // 订单业务服务
   kerwin-starter // 自定义springboot starter模块
      spring-cloud-starter-kerwin-gray // 灰度发布starter包 (核心代码都在这里)
   kerwin-user // 用户模块
      user-app // 用户业务服务
      user-client // 用户client（Feign和DTO）

核心包spring-cloud-starter-kerwin-gray结构介绍

054cac76179f8dc74d1b433d1e4b1440.png

入口Spring Cloud Gateway实现灰度发布设计（一些基础信息类在下面）

在请求进入网关时开始对是否要请求灰度版本进行判断，通过Spring Cloud Gateway的过滤器实现，在调用下游服务时重写一个Ribbon的负载均衡器实现调用时对灰度状态进行判断。

存取请求灰度标记Holder（业务服务也是使用的这个）

使用ThreadLocal记录每个请求线程的灰度标记，会在前置过滤器中将标记设置到ThreadLocal中。

public class GrayFlagRequestHolder {
    /**
     * 标记是否使用灰度版本
     * 具体描述请查看 {@link com.kerwin.gray.enums.GrayStatusEnum}
     */
    private static final ThreadLocal<GrayStatusEnum> grayFlag = new ThreadLocal<>();
    public static void setGrayTag(final GrayStatusEnum tag) {
        grayFlag.set(tag);
    }
    public static GrayStatusEnum getGrayTag() {
        return grayFlag.get();
    }
    public static void remove() {
        grayFlag.remove();
    }
}

前置过滤器

在前置过滤器中会对请求是否要使用灰度版本进行判断，并且会将灰度状态枚举GrayStatusEnum设置到GrayRequestContextHolder中存储这一个请求的灰度状态枚举，在负载均衡器中会取出灰度状态枚举判断要调用那个版本的服务，同时这里还实现了Ordered 接口会对网关的过滤器进行的排序，关注公众号：互联网架构师，回复关键词：9 获取阿里内部Java性能调优手册！这里我们将这个过滤器的排序设置为Ordered.HIGHEST_PRECEDENCE int的最小值，保证这个过滤器最先执行。

public class GrayGatewayBeginFilter implements GlobalFilter, Ordered {
    @Autowired
    private GrayGatewayProperties grayGatewayProperties;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        GrayStatusEnum grayStatusEnum = GrayStatusEnum.ALL;
        // 当灰度开关打开时才进行请求头判断
        if (grayGatewayProperties.getEnabled()) {
            grayStatusEnum = GrayStatusEnum.PROD;
            // 判断是否需要调用灰度版本
            if (checkGray(exchange.getRequest())) {
                grayStatusEnum = GrayStatusEnum.GRAY;
            }
        }
        GrayFlagRequestHolder.setGrayTag(grayStatusEnum);
        ServerHttpRequest newRequest = exchange.getRequest().mutate()
                .header(GrayConstant.GRAY_HEADER, grayStatusEnum.getVal())
                .build();
        ServerWebExchange newExchange = exchange.mutate()
                .request(newRequest)
                .build();
        return chain.filter(newExchange);
    }

    /**
     * 校验是否使用灰度版本
     */
    private boolean checkGray(ServerHttpRequest request) {
        if (checkGrayHeadKey(request) || checkGrayIPList(request) || checkGrayCiryList(request) || checkGrayUserNoList(request)) {
            return true;
        }
        return false;
    }

    /**
     * 校验自定义灰度版本请求头判断是否需要调用灰度版本
     */
    private boolean checkGrayHeadKey(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        if (headers.containsKey(grayGatewayProperties.getGrayHeadKey())) {
            List<String> grayValues = headers.get(grayGatewayProperties.getGrayHeadKey());
            if (!Objects.isNull(grayValues)
                    && grayValues.size() > 0
                    && grayGatewayProperties.getGrayHeadValue().equals(grayValues.get(0))) {
                return true;
            }
        }
        return false;
    }

    /**
     * 校验自定义灰度版本IP数组判断是否需要调用灰度版本
     */
    private boolean checkGrayIPList(ServerHttpRequest request) {
        List<String> grayIPList = grayGatewayProperties.getGrayIPList();
        if (CollectionUtils.isEmpty(grayIPList)) {
            return false;
        }
        String realIP = request.getHeaders().getFirst("X-Real-IP");
        if (realIP == null || realIP.isEmpty()) {
            realIP = request.getRemoteAddress().getAddress().getHostAddress();
        }
        if (realIP != null && CollectionUtils.contains(grayIPList.iterator(), realIP)) {
            return true;
        }
        return false;
    }

    /**
     * 校验自定义灰度版本城市数组判断是否需要调用灰度版本
     */
    private boolean checkGrayCiryList(ServerHttpRequest request) {
        List<String> grayCityList = grayGatewayProperties.getGrayCityList();
        if (CollectionUtils.isEmpty(grayCityList)) {
            return false;
        }
        String realIP = request.getHeaders().getFirst("X-Real-IP");
        if (realIP == null || realIP.isEmpty()) {
            realIP = request.getRemoteAddress().getAddress().getHostAddress();
        }
        // 通过IP获取当前城市名称
        // 这里篇幅比较长不具体实现了,想要实现的可以使用ip2region.xdb,这里写死cityName = "本地"
        String cityName = "本地";
        if (cityName != null && CollectionUtils.contains(grayCityList.iterator(), cityName)) {
            return true;
        }
        return false;
    }

    /**
     * 校验自定义灰度版本用户编号数组（我们系统不会在网关获取用户编号这种方法如果需要可以自己实现一下）
     */
    private boolean checkGrayUserNoList(ServerHttpRequest request) {
        List<String> grayUserNoList = grayGatewayProperties.getGrayUserNoList();
        if (CollectionUtils.isEmpty(grayUserNoList)) {
            return false;
        }
        return false;
    }

    @Override
    public int getOrder() {
        // 设置过滤器的执行顺序，值越小越先执行
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

后置过滤器

后置过滤器是为了在调用完下游业务服务后在响应之前将 GrayFlagRequestHolder 中的 ThreadLocal 清除避免照成内存泄漏。

public class GrayGatewayAfterFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 请求执行完必须要remore当前线程的ThreadLocal
        GrayFlagRequestHolder.remove();
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        // 设置过滤器的执行顺序，值越小越先执行
        return Ordered.LOWEST_PRECEDENCE;
    }
}

全局异常处理器

全局异常处理器是为了处理异常情况下将 GrayFlagRequestHolder 中的 ThreadLocal 清除避免照成内存泄漏，如果在调用下游业务服务时出现了异常就无法进入后置过滤器。

public class GrayGatewayExceptionHandler implements WebExceptionHandler, Ordered {
    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        // 请求执行完必须要remore当前线程的ThreadLocal
        GrayFlagRequestHolder.remove();
        ServerHttpResponse response = exchange.getResponse();
        if (ex instanceof ResponseStatusException) {
            // 处理 ResponseStatusException 异常
            ResponseStatusException responseStatusException = (ResponseStatusException) ex;
            response.setStatusCode(responseStatusException.getStatus());
            // 可以根据需要设置响应头等
            return response.setComplete();
        } else {
            // 处理其他异常
            response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
            // 可以根据需要设置响应头等
            return response.setComplete();
        }
    }

    @Override
    public int getOrder() {
        // 设置过滤器的执行顺序，值越小越先执行
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

自定义Ribbon负载均衡路由（业务服务也是使用的这个）

「灰度Ribbon负载均衡路由抽象类：」 这里提供了两个获取服务列表的方法，会对GrayFlagRequestHolder 中存储的当前线程灰度状态枚举进行判断，如果枚举值为GrayStatusEnum.ALL则响应全部服务列表不区分版本，如果枚举值为GrayStatusEnum.PROD则返回生产版本的服务列表，如果枚举值为GrayStatusEnum.GRAY则返回灰度版本的服务列表，版本号会在GrayVersionProperties 中配置，通过服务列表中在Nacos的metadata中设置的version和GrayVersionProperties的版本号进行匹配出对应版本的服务列表。

public abstract class AbstractGrayLoadBalancerRule extends AbstractLoadBalancerRule {
    @Autowired
    private GrayVersionProperties grayVersionProperties;

    @Value("${spring.cloud.nacos.discovery.metadata.version}")
    private String metaVersion;

    /**
     * 只有已启动且可访问的服务器，并对灰度标识进行判断
     */
    public List<Server> getReachableServers() {
        ILoadBalancer lb = getLoadBalancer();
        if (lb == null) {
            return new ArrayList<>();
        }
        List<Server> reachableServers = lb.getReachableServers();

        return getGrayServers(reachableServers);
    }

    /**
     * 所有已知的服务器，可访问和不可访问，并对灰度标识进行判断
     */
    public List<Server> getAllServers() {
        ILoadBalancer lb = getLoadBalancer();
        if (lb == null) {
            return new ArrayList<>();
        }
        List<Server> allServers = lb.getAllServers();
        return getGrayServers(allServers);
    }

    /**
     * 获取灰度版本服务列表
     */
    protected List<Server> getGrayServers(List<Server> servers) {
        List<Server> result = new ArrayList<>();
        if (servers == null) {
            return result;
        }
        String currentVersion = metaVersion;
        GrayStatusEnum grayStatusEnum = GrayFlagRequestHolder.getGrayTag();
        if (grayStatusEnum != null) {
            switch (grayStatusEnum) {
                case ALL:
                    return servers;
                case PROD:
                    currentVersion = grayVersionProperties.getProdVersion();
                    break;
                case GRAY:
                    currentVersion = grayVersionProperties.getGrayVersion();
                    break;
            }
        }

        for (Server server : servers) {
            NacosServer nacosServer = (NacosServer) server;
            Map<String, String> metadata = nacosServer.getMetadata();
            String version = metadata.get("version");
            // 判断服务metadata下的version是否于设置的请求版本一致
            if (version != null && version.equals(currentVersion)) {
                result.add(server);
            }
        }
        return result;
    }
}

「自定义轮询算法实现GrayRoundRobinRule：」 代码篇幅太长了这里只截取代码片段，我这里是直接拷贝了Ribbon的轮询算法，将里面获取服务列表的方法换成了自定义AbstractGrayLoadBalancerRule 中的方法，其它算法也可以通过类似的方式实现。

5eca73e4065ab0b090ac742c2a351682.png

业务服务实现灰度发布设计

自定义SpringMVC请求拦截器

自定义SpringMVC请求拦截器获取上游服务的灰度请求头，如果获取到则设置到GrayFlagRequestHolder 中，之后如果有后续的RPC调用同样的将灰度标记传递下去。

@SuppressWarnings("all")
public class GrayMvcHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String grayTag = request.getHeader(GrayConstant.GRAY_HEADER);
        // 如果HttpHeader中灰度标记存在，则将灰度标记放到holder中，如果需要就传递下去
        if (grayTag!= null) {
            GrayFlagRequestHolder.setGrayTag(GrayStatusEnum.getByVal(grayTag));
        }
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        GrayFlagRequestHolder.remove();
    }
}

自定义OpenFeign请求拦截器

自定义OpenFeign请求拦截器，取出自定义SpringMVC请求拦截器中设置到GrayFlagRequestHolder中的灰度标识，并且放到调用下游服务的请求头中，将灰度标记传递下去。

public class GrayFeignRequestInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate template) {
        // 如果灰度标记存在，将灰度标记通过HttpHeader传递下去
        GrayStatusEnum grayStatusEnum = GrayFlagRequestHolder.getGrayTag();
        if (grayStatusEnum != null ) {
            template.header(GrayConstant.GRAY_HEADER, Collections.singleton(grayStatusEnum.getVal()));
        }
    }
}

基础信息设计

这里会定义一些基础参数，比如是否开启灰度还有什么请求需要使用灰度版本等，为后续业务做准备。

  • 调用业务服务时设置的灰度统一请求头

public interface GrayConstant {
    /**
     * 灰度统一请求头
     */
    String GRAY_HEADER="gray";
}

  • 灰度版本状态枚举

public enum GrayStatusEnum {
    ALL("ALL","可以调用全部版本的服务"),
    PROD("PROD","只能调用生产版本的服务"),
    GRAY("GRAY","只能调用灰度版本的服务");
    GrayStatusEnum(String val, String desc) {
        this.val = val;
        this.desc = desc;
    }
    private String val;
    private String desc;
    public String getVal() {
        return val;
    }
    public static GrayStatusEnum getByVal(String val){
        if(val == null){
            return null;
        }
        for (GrayStatusEnum value : values()) {
            if(value.val.equals(val)){
                return value;
            }
        }
        return null;
    }
}

  • 网关灰度配置信息类

@Data
@Configuration
@RefreshScope
@ConfigurationProperties("kerwin.tool.gray.gateway")
public class GrayGatewayProperties {

    /**
     * 灰度开关（如果开启灰度开关则进行灰度逻辑处理，如果关闭则走正常处理逻辑）
     * PS：一般在灰度发布测试完成以后会将线上版本都切换成灰度版本完成全部升级，这时候应该关闭灰度逻辑判断
     */
    private Boolean enabled = false;

    /**
     * 自定义灰度版本请求头 （通过grayHeadValue来匹配请求头中的值如果一致就去调用灰度版本,用于公司测试）
     */
    private String grayHeadKey="gray";

    /**
     * 自定义灰度版本请求头匹配值
     */
    private String grayHeadValue="gray-996";

    /**
     * 使用灰度版本IP数组
     */
    private List<String> grayIPList = new ArrayList<>();

    /**
     * 使用灰度版本城市数组
     */
    private List<String> grayCityList = new ArrayList<>();

    /**
     * 使用灰度版本用户编号数组（我们系统不会在网关获取用户编号这种方法如果需要可以自己实现一下）
     */
    private List<String> grayUserNoList = new ArrayList<>();
}

  • 全局版本配置信息类

@Data
@Configuration
@RefreshScope
@ConfigurationProperties("kerwin.tool.gray.version")
public class GrayVersionProperties {
    /**
     * 当前线上版本号
     */
    private String prodVersion;

    /**
     * 灰度版本号
     */
    private String grayVersion;
}

  • 全局自动配置类

@Configuration
// 可以通过@ConditionalOnProperty设置是否开启灰度自动配置 默认是不加载的
@ConditionalOnProperty(value = "kerwin.tool.gray.load",havingValue = "true")
@EnableConfigurationProperties(GrayVersionProperties.class)
public class GrayAutoConfiguration {
    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(value = GlobalFilter.class)
    @EnableConfigurationProperties(GrayGatewayProperties.class)
    static class GrayGatewayFilterAutoConfiguration {
        @Bean
        public GrayGatewayBeginFilter grayGatewayBeginFilter() {
            return new GrayGatewayBeginFilter();
        }
        @Bean
        public GrayGatewayAfterFilter grayGatewayAfterFilter() {
            return new GrayGatewayAfterFilter();
        }
        @Bean
        public GrayGatewayExceptionHandler grayGatewayExceptionHandler(){
            return new GrayGatewayExceptionHandler();
        }
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(value = WebMvcConfigurer.class)
    static class GrayWebMvcAutoConfiguration {
        /**
         * Spring MVC 请求拦截器
         * @return WebMvcConfigurer
         */
        @Bean
        public WebMvcConfigurer webMvcConfigurer() {
            return new WebMvcConfigurer() {
                @Override
                public void addInterceptors(InterceptorRegistry registry) {
                    registry.addInterceptor(new GrayMvcHandlerInterceptor());
                }
            };
        }
    }
    @Configuration
    @ConditionalOnClass(value = RequestInterceptor.class)
    static class GrayFeignInterceptorAutoConfiguration {
        /**
         * Feign拦截器
         * @return GrayFeignRequestInterceptor
         */
        @Bean
        public GrayFeignRequestInterceptor grayFeignRequestInterceptor() {
            return new GrayFeignRequestInterceptor();
        }
    }
}

项目运行配置

这里我会启动五个服务，一个网关服务、一个用户服务V1版本、一个订单服务V1版本、一个用户服务V2版本、一个订单服务V2版本，来演示灰度发布效果。

PS：Nacos的命名空间我这里叫spring-cloud-gray-example可以自己创建一个也可以换成自己的命名空间，源码里面配置都是存在的，有问题看源码就行

配置Nacos全局配置文件（common-config.yaml）

所有服务都会使用到这个配置

kerwin:
  tool:
    gray:
      ## 配置是否加载灰度自动配置类，如果不配置那么默认不加载
      load: true
      ## 配置生产版本和灰度版本号
      version:
        prodVersion: V1
        grayVersion: V2

## 配置Ribbon调用user-app和order-app服务时使用我们自定义灰度轮询算法
user-app:
  ribbon:
    NFLoadBalancerRuleClassName: com.kerwin.gray.loadbalancer.GrayRoundRobinRule
order-app:
  ribbon:
    NFLoadBalancerRuleClassName: com.kerwin.gray.loadbalancer.GrayRoundRobinRule
fd6115ff7187cf1c775801ec830f6bb6.png

配置网关Nacos配置文件（gateway-app.yaml）

kerwin:
  tool:
    gray:
      gateway:
        ## 是否开启灰度发布功能
        enabled: true
        ## 自定义灰度版本请求头
        grayHeadKey: gray
        ## 自定义灰度版本请求头匹配值
        grayHeadValue: gray-996
        ## 使用灰度版本IP数组
        grayIPList:
          - '127.0.0.1'
        ## 使用灰度版本城市数组
        grayCityList:
          - 本地
b9808cbd2b41ec4f32e3d2fd51800b57.png

启动网关服务

网关服务启动一个就行，直接Debug启动即可，方便调试源码

启动业务服务V1 和 V2版本（用户服务和订单服务都用这种方式启动）

先直接Debug启动会在IDEA这个位置看到一个对应启动类名称的信息

303586a2d211643fef17fc2282941bad.png

点击Edit编辑这个启动配置

abfb348a35526ee57aba6e841f3d2efc.png

复制一个对应启动配置作为V2版本，自己将Name改成自己能区分的即可

bc867eb88c899493f12dfd27e0d924c2.png

配置启动参数，第一步点击Modify options 然后第二步将Add VM options勾选上，第三步填写对应服务的启动端口和Nacos的metadata.version，我这里用户服务V1版本配置为-Dserver.port=7201 -Dspring.cloud.nacos.discovery.metadata.version=V1，用户服务V2版本配置为-Dserver.port=7202 -Dspring.cloud.nacos.discovery.metadata.version=V2，订单服务配置类似，配置好后点Apply。

bf085345503db742e424ef063ba221a5.png

最后启动好的服务信息

d9551f6ed8f542396c9e739a284eaa87.png

灰度效果演示

源码中的user-app提供了一个获取用户信息的接口并且会携带当前服务的端口和版本信息，order-app服务提供了一个获取订单信息的接口，会去远程调用user-app获取订单关联的用户信息，并且也会携带当前服务的端口和版本信息响应。

场景一（关闭灰度开关：不区分调用服务版本）

关闭灰度开关有两个配置可以实现

1、在项目启动之前修改Nacos全局配置文件中的kerwin.tool.gray.load 配置是否加载灰度自动配置类，只要配置不为true就不会加载整个灰度相关类

5e6150509506bb1f6464579ba8f41272.png

2、关闭网关灰度开关，修改网关Nacos配置文件中的kerwin.tool.gray.gateway.enabled ，只要配置不为true就不会进行灰度判断。

调用演示

这里调用不一定就是Order服务版本为V1 User服务版本也为V1，也有可能Order服务版本为V1 User服务版本也为V2.

  • 第一次调用，Order服务版本为V1，User服务版本也为V1

398382e6532637a8d6ca18d919d1c162.png

  • 第二次调用，Order服务版本为V2，User服务版本也为V2

f0c685762ca615b190ae724d554bbc1f.png

场景二（开启灰度开关：只调用生产版本）

修改网关Nacos配置文件中的kerwin.tool.gray.gateway.enabled 设置为true，其它灰度IP数组和城市数组配置匹配不上就行，这样怎么调用都是V1版本，因为在GrayVersionProperties版本配置中设置的生产版本就是为V1灰度版本为V2。

dad14284db1f6f503b6cd514b7f152d6.png 8838ff24031ea05420ac77abc10df765.png

场景三（开启灰度开关：通过请求头、ip、城市匹配调用灰度版本）

这里通过请求头测试，携带请求头gray=gray-996访问网关那么流量就会都进入灰度版本V2。

b36d66ea88cb5fac94f881c045e62cae.png 86e529bf2af19a768a402e638ed148e6.png

源码

https://gitee.com/kerwin_code/spring-cloud-gray-example

— 完 —

如喜欢本文，请点击右上角，把文章分享到朋友圈

1、2T架构师学习资料干货分享

2、10000+TB 资源，阿里云盘，牛逼！！

3、基本涵盖了Spring所有核心知识点总结

  · END ·

最后，关注公众号互联网架构师，在后台回复：2T，可以获取我整理的 Java 系列面试题和答案，非常齐全。

如果这篇文章对您有所帮助，或者有所启发的话，帮忙扫描上方二维码关注一下，您的支持是我坚持写作最大的动力。

求一键三连点赞、转发、在看

# spring cloud # 负载均衡 # spring # 后端 # 运维
GitHub 加速计划 / na / nacos
29.84 K
12.75 K
下载
Nacos是由阿里巴巴开源的服务治理中间件，集成了动态服务发现、配置管理和服务元数据管理功能，广泛应用于微服务架构中，简化服务治理过程。
最近提交(Master分支：3 个月前 )
c5e5a822 23 小时前
93ea0ddb 23 小时前
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

avatar GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

avatar GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

avatar GitCode 开源社区