nacos動態網關gateway+docker部署

首先啓動nacos,在docker中安裝好,啓動nacos服務

nacos的管理頁面: nacos默認端口是8848

編寫網關服務: nacos-gateway

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>
    <parent>
        <groupId>com.wm</groupId>
        <artifactId>nacos-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>gateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gateway</name>
    <description>網關服務</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!--nacos配置中心-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--健康檢查使用,否則會出現該實例像gateway等都不認-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>


            <!-- tag::plugin[] -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!--指定生成的鏡像名-->
                    <imageName>mynacosdocker/${project.artifactId}</imageName>
                    <!--指定標籤-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 指定 Dockerfile 路徑 ${project.basedir}：項目根路徑下-->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定遠程 docker api地址-->
                    <dockerHost>http://虛擬機ip:2375</dockerHost>
                    <!-- 這裏是複製 jar 包到 docker 容器指定目錄配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路徑 此處配置的 即對應 target 目錄-->
                            <directory>${project.build.directory}</directory>
                            <!-- 需要包含的 jar包 ，這裏對應的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

目錄結構,需要用bootstrap.yml ,原因是我也使用了nacosa的配置中心,優先於application.yml加載,且不能被覆蓋

bootstrap.yml的配置:

server:
  port: 9100
spring:
  application:
    name: nacos-gateway
  cloud:
    nacos:
      discovery:
        server-addr: nacosip:8848
      config:
        server-addr: nacosip:8848
        file-extension: yml
        timeout: 5000
        group: DEFAULT_GROUP
        refreshable-dataids: ${spring.application.name}

# 暴露端點
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

在nacos頁面配置遠程配置文件,更多細節詳情請查看官網的配置: https://nacos.io/zh-cn/docs/sdk.html

在啓動類,註冊服務發現:

package com.wm.gateway;

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

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {

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

}

動態網關的核心類:

package com.wm.gateway.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.http.ResponseEntity;
import reactor.core.publisher.Mono;

/***
 * @ClassName: DynamicRouteService
 * @Description: 動態路由服務  重寫cloud的動態路由操作
 * @Author: wm_yu
 * @Create_time: 17:30 2020-3-27
 */
public abstract class AbstractDynamicRouteService implements ApplicationEventPublisherAware {

    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.publisher = applicationEventPublisher;
    }


    //增加路由
    public String add(RouteDefinition definition) {
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return "success";
    }


    //更新路由
    public String update(RouteDefinition definition) {
        try {
            delete(definition.getId());
        } catch (Exception e) {
            return "update fail,not find route  routeId: "+ definition.getId();
        }
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "success";
        } catch (Exception e) {
            return "update route fail";
        }
    }



    //刪除路由
    public Mono<ResponseEntity<Object>> delete(String id) {
        return this.routeDefinitionWriter.delete(Mono.just(String.valueOf(id)))
                .then(Mono.defer(() -> Mono.just(ResponseEntity.ok().build())))
                .onErrorResume(t -> t instanceof NotFoundException, t -> Mono.just(ResponseEntity.notFound().build()));
    }
}

需要編寫監聽nacos配置文件的變化,按照官網的模式來的:

package com.wm.gateway.service;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Properties;
import java.util.concurrent.Executor;


/**
 * @author 半卷流年
 * @date 2020-7-3 11:11
 */
@Service
@Slf4j
public class RouteService extends AbstractDynamicRouteService {

    private static final String DATA_ID = "gateway.json";

      /** 刷新路由
     * @return
     */
    //@Bean
    public void autoRefresh() throws NacosException {
        Properties properties = new Properties();
        properties.put(PropertyKeyConst.SERVER_ADDR, "47.104.15.104:8848");
        ConfigService configService = NacosFactory.createConfigService(properties);
        //nacos會在配置文件修改時立即進行推送,否則會每隔30s進行推送最新的配置
        configService.addListener(DATA_ID, "DEFAULT_GROUP", new Listener() {
            @Override
            public Executor getExecutor() {
                return null;
            }
            @Override
            public void receiveConfigInfo(String configInfo) {
                log.info("監聽到nacos的配置變化:{}",configInfo);
                JSONObject object = JSONObject.parseObject(configInfo);
                if(!CollectionUtils.isEmpty(object)){
                    //更新路由
                    List<RouteDefinition> list = JSONObject.parseArray(object.get("routeList").toString(), RouteDefinition.class);
                    //List<RouteDefinition> list = JSON.parseArray(object.getString("routeList")).toJavaList(RouteDefinition.class);
                    if(!CollectionUtils.isEmpty(list)){
                        for (RouteDefinition definition : list) {
                              //刷新路由
                            update(definition);
                        }
                    }
                }
            }
        });
    }
}

具體的我在代碼中已經寫明瞭:

然後在nacos配置中新增 gateway.json配置文件,專門配置網關的服務

網關json的具體內容如下:

{
"routeList":[
        {
            "id":"consumer",
            "predicates":[
                {
                    "name":"Path",
                    "args":{
                        "_genkey_0":"/consumer/**"
                    }
                }
            ],
            "filters":[

            ],
            "uri":"lb://nacos-consumer",
            "order":1
        },
 {
            "id":"provider",
            "predicates":[
                {
                    "name":"Path",
                    "args":{
                        "_genkey_0":"/provider/**"
                    }
                }
            ],
            "filters":[

            ],
            "uri":"lb://nacos-provider",
            "order":2
        }
    ]
}

在spring啓動的時候也加載配置網關配置到內存中:

package com.wm.gateway.config;

import com.wm.gateway.service.RouteService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * @author 半卷流年
 * @date 2020-7-3 13:54
 */
@Component
@Slf4j
public class AppApplicationRunner implements CommandLineRunner {

    @Autowired
    private RouteService routeService;

    @Override
    public void run(String... args) throws Exception {
      log.info("初始化加載路由.............");
        routeService.autoRefresh();
    }
}

下面我們啓動網關服務:

如下:

啓動項目,初始化和網關都加載了,我們查看當前內存所有的網關信息: http://localhost:9100/actuator/gateway/routes

可以看到網關加載成功了,下面我們更改網關的配置,看nacos監聽到了並且更新了網關路由信息不:

進行發佈:

可以看到確實是監聽到了,數據的變化,再次查看所有的路由信息:

刷新了網關信息,改回原來的樣子,接着創建consumer和provider服務:

provider服務:

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>
    <parent>
        <groupId>com.wm</groupId>
        <artifactId>nacos-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>provider</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--nacos配置中心-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!--web依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--健康檢查使用,否則會出現該實例像gateway等都不認-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>2.2.1.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <!-- tag::plugin[] -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!--指定生成的鏡像名-->
                    <imageName>mynacosdocker/${project.artifactId}</imageName>
                    <!--指定標籤-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 指定 Dockerfile 路徑 ${project.basedir}：項目根路徑下-->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定遠程 docker api地址-->
                    <dockerHost>http://虛擬機ip:2375</dockerHost>
                    <!-- 這裏是複製 jar 包到 docker 容器指定目錄配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路徑 此處配置的 即對應 target 目錄-->
                            <directory>${project.build.directory}</directory>
                            <!-- 需要包含的 jar包 ，這裏對應的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

啓動類也需要服務發現:

package com.wm.provider;

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

@SpringBootApplication
@EnableDiscoveryClient
public class ProviderApplication {

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

}

bootstrap.yml文件:


server:
  port: 9999
spring:
  application:
    name: nacos-provider
  cloud:
    nacos:
      discovery:
        server-addr: nacosip:8848
      config:
        server-addr: nacosip:8848
        file-extension: yml

# 暴露端點
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

nacos的配置:

啓動provider服務:

可以看到nacos中已經有兩個實例了:

下面創建consumer服務:

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>
    <parent>
        <groupId>com.wm</groupId>
        <artifactId>nacos-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!--nacos配置中心-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--web依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--feign依賴-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>2.2.2.RELEASE</version>
        </dependency>

        <!--健康檢查使用,否則會出現該實例像gateway等都不認-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>


            <!-- tag::plugin[] -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!--指定生成的鏡像名-->
                    <imageName>nacosconsumer/${project.artifactId}</imageName>
                    <!--指定標籤-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 指定 Dockerfile 路徑 ${project.basedir}：項目根路徑下-->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定遠程 docker api地址-->
                    <dockerHost>http://虛擬機ip:2375</dockerHost>
                    <!-- 這裏是複製 jar 包到 docker 容器指定目錄配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路徑 此處配置的 即對應 target 目錄-->
                            <directory>${project.build.directory}</directory>
                            <!-- 需要包含的 jar包 ，這裏對應的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>


        </plugins>
    </build>

</project>

使用到了feign,配置feign的日誌:

package com.wm.consumer.config;

/***
 * @ClassName: FeignLogConfig
 * @Description: feign日誌輸出
 * @Author: wm_yu
 * @Create_time: 15:41 2020-3-27
 */

import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Feign logging
 * A logger is created for each Feign client created. By default the name of the logger is the full class name of the interface used to create the Feign client. Feign logging only responds to the DEBUG level.
 *
 *   bootstrap.yml
 *
 * logging.level.project.user.UserClient: DEBUG
 *
 *
 * The Logger.Level object that you may configure per client, tells Feign how much to log. Choices are:
 *
 * 可以爲每個客戶端配置日誌級別(Logger.Level)，選項有：
 *
 * NONE, No logging (DEFAULT).
 * BASIC, Log only the request method and URL and the response status code and execution time.
 * HEADERS, Log the basic information along with request and response headers.
 * FULL, Log the headers, body, and metadata for both requests and responses.
 * For example, the following would set the Logger.Level to FULL:
 *
 * 下例將日誌級別設爲全部(FULL)：
 *
 * @Configuration
 * public class FooConfiguration {
 *     @Bean
 *     Logger.Level feignLoggerLevel() {
 *         return Logger.Level.FULL;
 *     }
 * }
 */

@Configuration
public class FeignLogConfig {
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

需要在yml中指定:

bootstrap.yml的配置:


server:
  port: 9998
spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: nacosip:8848
      config:
        server-addr: nacosip:8848
        file-extension: yml
logging:
  level:
    root : INFO
    #### feign日誌
    com.wm.consumer.feign: debug
data-id: ${spring.application.name}


# 暴露端點
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

feign接口:

package com.wm.consumer.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @author 半卷流年
 * @date 2020-7-1 16:20
 */
@FeignClient(value = "nacos-provider")
public interface NacosFeign {

    @GetMapping(value = "/provider/test")
     String test(@RequestParam("name") String name);
}

controller:

package com.wm.consumer.controller;

import com.alibaba.nacos.api.config.ConfigService;
import com.wm.consumer.feign.NacosFeign;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 半卷流年
 * @date 2020-7-1 16:25
 */
@RestController
@RequestMapping("/consumer")
@Slf4j
@RefreshScope //刷新nacos配置
public class ConsumerController {


    @Value("${consumer:test}")
    private String consumer;

    @Autowired
    private NacosFeign nacosFeign;


    @GetMapping("/test")
    public String test(String name){
        log.info("請求consumer:{}",name);
        return nacosFeign.test(name);
    }



    @GetMapping("/getConfigh")
    public String getConfigh(){
        StringBuilder sb = new StringBuilder();
        return sb.append(consumer).append("-------").append("").toString();
    }



}

這裏使用了@RefreshScope //刷新nacos配置 ,這個會在讀取nacos配置中如果有變化,會刷新讀取的配置值

啓動consumer

下面開始連接虛擬機的docker製作鏡像,先使用idea連接遠程docker,需要先下載docker插件

配置docker地址,默認端口爲2375,需要先在虛擬機中開放這個端口具體操作查看這篇博客: https://blog.csdn.net/qq_33401710/article/details/88303976

連接之後,在pom中加入docker插件,指定docker的名稱,版本,連接的遠程docker地址,指定dockerfile的位置:

如下:

 <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>


            <!-- tag::plugin[] -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!--指定生成的鏡像名-->
                    <imageName>mynacosdocker/${project.artifactId}</imageName>
                    <!--指定標籤-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 指定 Dockerfile 路徑 ${project.basedir}：項目根路徑下-->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定遠程 docker api地址-->
                    <dockerHost>http://虛擬機ip:2375</dockerHost>
                    <!-- 這裏是複製 jar 包到 docker 容器指定目錄配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路徑 此處配置的 即對應 target 目錄-->
                            <directory>${project.build.directory}</directory>
                            <!-- 需要包含的 jar包 ，這裏對應的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>

        </plugins>

創建Dockerfile文件,名稱別寫錯了,大小寫嚴格哈

FROM java:8
ADD target/gateway-0.0.1-SNAPSHOT.jar gateway.jar
EXPOSE 9100
ENTRYPOINT ["java","-jar","/gateway.jar"]

下面開始製作docker鏡像:

先製作打包成jar ,在使用如下:

等待制作成功就可以看到剛製作成的鏡像了:

也可以使用命令查看:

依次製作consumer,provider的鏡像,在生成容器啓動,就可以了:

如果查看容器啓動的日誌,使用 : docker logs -f 容器id ,-f是動態監聽日誌,不使用-f是當前的日誌

下面我們使用postman來請求下網關的服務,轉發到對應的模塊去:

可以看到成功了,端口9100是gateway服務的,而請求的Url是consumer的,還用到了feign請求,請求成功了;

nacos動態網關gateway+docker部署

nacos動態網關gateway+docker部署

java反射獲取到接口和類的方法對應的參數名稱(非參數類型)

spring cloud gateway+自定義全局/過濾器工廠

linux中安裝consul

spring cloud gateway網關處理跨域

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結