2. 程式人生 > >服務化改造實踐（三） | Dubbo + Zipkin

服務化改造實踐（三） | Dubbo + Zipkin

阿新 • • 發佈：2018-10-21
next 另一個 興趣 hit scrip dep -bash find exception

隨著業務的發展，應用的規模不斷的擴大，傳統的應用架構無法滿足訴求，服務化架構改造勢在必行，以 Dubbo 為代表的分布式服務框架成為了服務化改造架構中的基石。隨著微服務理念逐漸被大眾接受，應用進一步向更細粒度拆分，並且，不同的應用由不同的開發團隊獨立負責，整個分布式系統變得十分復雜。沒有人能夠清晰及時的知道當前系統整體的依賴關系。當出現問題時，也無法及時知道具體是鏈路上的哪個環節出了問題。

在這個背景下，Google 發表了 Dapper 的論文，描述了如何通過一個分布式追蹤系統解決上述問題。基於該論文，各大互聯網公司實現並部署了自己的分布式追蹤系統，其中比較出名的有阿裏巴巴的 EagleEye。本文中提到的 Zipkin 是 Twitter 公司開源的分布式追蹤系統。下面會詳細介紹如何在 Dubbo 中使用 Zipkin 來實現分布式追蹤。

Zipkin 簡介

Zipkin 是基於 Dapper 論文實現，由 Twitter 開源的分布式追蹤系統，通過收集分布式服務執行時間的信息來達到追蹤服務調用鏈路、以及分析服務執行延遲等目的。

Zipkin 架構

技術分享圖片

Collector 收集器、Storage 存儲、API、UI 用戶界面等幾部分構成了 Zipkin Server 部分，對應於 GitHub 上 openzipkin/zipkin 這個項目。而收集應用中調用的耗時信息並將其上報的組件與應用共生，並擁有各個語言的實現版本，其中 Java 的實現是 GitHub 上 openzipkin/brave。除了 Java 客戶端實現之外，openzipkin 還提供了許多其他語言的實現，其中包括了 go、php、JavaScript、.net、ruby 等，具體列表可以參閱 Zipkin 的 Exiting instrumentations。

Zipkin 的工作過程

當用戶發起一次調用時，Zipkin 的客戶端會在入口處為整條調用鏈路生成一個全局唯一的 trace id，並為這條鏈路中的每一次分布式調用生成一個 span id。span 與 span 之間可以有父子嵌套關系，代表分布式調用中的上下遊關系。span 和 span 之間可以是兄弟關系，代表當前調用下的兩次子調用。一個 trace 由一組 span 組成，可以看成是由 trace 為根節點，span 為若幹個子節點的一棵樹。

技術分享圖片

Span 由調用邊界來分隔，在 Zipkin 中，調用邊界由以下四個 annotation 來表示：

  • cs - Clent Sent 客戶端發送了請求
  • sr - Server Receive 服務端接受到請求
  • ss - Server Send 服務端處理完畢，向客戶端發送回應
  • cr - Client Receive 客戶端收到結果

顯然，通過這四個 annotation 上的時間戳，可以輕易的知道一次完整的調用在不同階段的耗時，比如：

  • sr - cs 代表了請求在網絡上的耗時
  • ss - sr 代表了服務端處理請求的耗時
  • cr - ss 代表了回應在網絡上的耗時
  • cr - cs 代表了一次調用的整體耗時

Zipkin 會將 trace 相關的信息在調用鏈路上傳遞，並在每個調用邊界結束時異步的把當前調用的耗時信息上報給 Zipkin Server。Zipkin Server 在收到 trace 信息後，將其存儲起來，Zipkin 支持的存儲類型有 inMemory、MySql、Cassandra、以及 ElasticsSearch 幾種方式。隨後 Zipkin 的 Web UI 會通過 API 訪問的方式從存儲中將 trace 信息提取出來分析並展示，如下圖所示：

技術分享圖片

在 Dubbo 中使用

由於 Brave 對 Dubbo 已經主動做了支持，在 Dubbo 中集成基於 Zipkin 的鏈路追蹤變的十分簡單。下面會按照 Brave 中關於 Dubbo RPC 支持的指引來說明如何在 Dubbo 中使用 Zipkin。

安裝 Zipkin Server

按照 Zipkin 官方文檔中的快速開始 來安裝 Zipkin，如下所示：

$ curl -sSL https://zipkin.io/quickstart.sh | bash -s
$ java -jar zipkin.jar

按照這種方式安裝的 Zipkin Server 使用的存儲類型是 inMemory 的。當服務器停機之後，所有收集到的 trace 信息會丟失，不適用於生產系統。如果在生產系統中使用，需要配置另外的存儲類型。Zipkin 支持 MySql、Cassandra、和 ElasticSearch。推薦使用 Cassandra 和 ElasticSearch，相關的配置請自行查閱官方文檔。

本文為了演示方便，使用的存儲是 inMemory 類型。成功啟動之後，可以在終端看到如下的提示：

$ java -jar zipkin.jar
Picked up JAVA_TOOL_OPTIONS: -Djava.awt.headless=true
                                    ********
                                  **        **
                                 *            *
                                **            **
                                **            **
                                 **          **
                                  **        **
                                    ********
                                      ****
                                      ****
        ****                          ****
     ******                           ****                                 ***
  ****************************************************************************
    *******                           ****                                 ***
        ****                          ****
                                       **
                                       **

             *****      **     *****     ** **       **     **   **
               **       **     **  *     ***         **     **** **
              **        **     *****     ****        **     **  ***
             ******     **     **        **  **      **     **   **

:: Powered by Spring Boot ::         (v2.0.5.RELEASE)

...

o.s.b.w.e.u.UndertowServletWebServer     : Undertow started on port(s) 9411 (http) with context path ‘‘
2018-10-10 18:40:31.605  INFO 21072 --- [           main] z.s.ZipkinServer                         : Started ZipkinServer in 6.835 seconds (JVM running for 8.35)

然後在瀏覽器中訪問 http://localhost:9411 驗證 WEB 界面。

配置 Maven 依賴

引入 Brave 依賴

新建一個新的 Java 工程，並在 pom.xml 中引入 Brave 相關的依賴如下：

    <properties>
        <brave.version>5.4.2</brave.version>
        <zipkin-reporter.version>2.7.9</zipkin-reporter.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 引入 zipkin brave 的 BOM 文件 -->
            <dependency>
                <groupId>io.zipkin.brave</groupId>
                <artifactId>brave-bom</artifactId>
                <version>${brave.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 引入 zipkin repoter 的 BOM 文件 -->
            <dependency>
                <groupId>io.zipkin.reporter2</groupId>
                <artifactId>zipkin-reporter-bom</artifactId>
                <version>${zipkin-reporter.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- 1. brave 對 dubbo 的集成 -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-instrumentation-dubbo-rpc</artifactId>
        </dependency>

        <!-- 2. brave 的 spring bean 支持 -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-spring-beans</artifactId>
        </dependency>

        <!-- 3. 在 SLF4J 的 MDC (Mapped Diagnostic Context) 中支持 traceId 和 spanId -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-context-slf4j</artifactId>
        </dependency>

        <!-- 4. 使用 okhttp3 作為 reporter -->
        <dependency>
            <groupId>io.zipkin.reporter2</groupId>
            <artifactId>zipkin-sender-okhttp3</artifactId>
        </dependency>
    </dependencies>

其中：

  1. 引入 brave-instrumentation-dubbo-rpc，brave 對 dubbo 的支持：https://github.com/openzipkin/brave/blob/master/instrumentation/dubbo-rpc/README.md
  2. 引入 brave-spring-beans，brave 對 spring bean 的支持：https://github.com/openzipkin/brave/blob/master/spring-beans/README.md
  3. 引入 brave-context-slf4j，brave 對 SLF4J 的支持，可以在 MDC 中使用 traceId 和 spanId：https://github.com/openzipkin/brave/blob/master/context/slf4j/README.md
  4. 引入 zipkin-sender-okhttp3，使用 okhttp3 上報數據：https://github.com/openzipkin/zipkin-reporter-java

引入 Dubbo 相關依賴

Dubbo 相關的依賴是 Dubbo 本身以及 Zookeeper 客戶端，在下面的例子中，我們將會使用獨立的 Zookeeper Server 作為服務發現。

    <dependencies>
        <!-- 1. Zookeeper 客戶端依賴 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
            <exclusions>
                <exclusion>
                    <groupId>io.netty</groupId>
                    <artifactId>netty</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 2. Dubbo 依賴 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>
    </dependencies>

其中：

  1. Dubbo 這裏依賴獨立的 Zookeeper Server 做服務發現，這裏使用的客戶端是 Curator
  2. 引入 Dubbo 框架的依賴，原則上 2.6 的任何版本都是工作的，這裏使用的是 2.6.2 版本

實現

我們這裏構造的場景是一個有兩個節點的服務依賴鏈，也就是，當一個 Dubbo 客戶端調用服務 A 時，服務 A 將會繼續調用服務 B。在這個例子中，服務 A 是 greeting service，它所依賴的下遊服務服務 B 是 hello service。

定義服務接口

為此需要事先定義兩個服務接口 GreetingService 以及 HelloService

  1. com.alibaba.dubbo.samples.api.GreetingService

    package com.alibaba.dubbo.samples.api;

public interface GreetingService {
    String greeting(String message);
}

  2. com.alibaba.dubbo.samples.api.HelloService

    package com.alibaba.dubbo.samples.api;

public interface HelloService {
    String hello(String message);
}

實現服務接口

為了區分對待，所有和 HelloService 相關的實現代碼都放在 hello 子包下，同理 GreetingService 相關的放在 greeting 子包下。

  1. 實現 com.alibaba.dubbo.samples.api.HelloService

    package com.alibaba.dubbo.samples.service.hello;

import com.alibaba.dubbo.samples.api.HelloService;

import java.util.Random;

public class HelloServiceImpl implements HelloService {
    @Override
    public String hello(String message) {
        try {
            // 通過 sleep 模擬業務邏輯處理時間
            Thread.sleep(new Random(System.currentTimeMillis()).nextInt(1000));
        } catch (InterruptedException e) {
            // no op
        }
        return "hello, " + message;
    }
}

  2. 實現 com.alibaba.dubbo.samples.api.GreetingService

    package com.alibaba.dubbo.samples.service.greeting;

import com.alibaba.dubbo.samples.api.GreetingService;
import com.alibaba.dubbo.samples.api.HelloService;

import java.util.Random;

public class GreetingServiceImpl implements GreetingService {
    // 下遊依賴服務，運行時靠 spring 容器註入 HelloService 的服務代理
    private HelloService helloService;

    public void setHelloService(HelloService helloService) {
        this.helloService = helloService;
    }

    @Override
    public String greeting(String message) {
        try {
            // 通過 sleep 模擬業務邏輯處理時間
            Thread.sleep(new Random(System.currentTimeMillis()).nextInt(1000));
        } catch (InterruptedException e) {
            // no op
        }
        return "greeting, " + helloService.hello(message);
    }
}

    這裏需要註意的是，GreetingServiceImpl 的實現中聲明了一個類型是 HelloService 的成員變量，並在 greeting 方法中，執行完自己邏輯之後又調用了 HelloService 上的 hello 方法。這裏的 helloService 的實現將會在運行態由外部註入，註入的不是 HelloServiceImpl 的實現，而是 HelloService 的遠程調用代理。通過這樣的方式，完成了在一個 Dubbo 服務中繼續調用另一個遠程 Dubbo 服務的目的。從鏈路追蹤的角度來說，客戶端調用 GreetingService 是一個 span，GreetingService 調用 HelloService 是另一個 span，並且兩者有父子關系，同屬於一個 trace，也就是屬於同一條調用鏈路。

    另外，在 GreetingServiceImpl 和 HelloServiceImpl 的實現中，通過 Thread.sleep 來模擬了處理業務邏輯的耗時，以便在 Zipkin UI 上更好的展示。

配置

為了專註在展示如何使用 Zipkin 這一點上，本文在配置和編程模型上沒有采用更多的高級技術，而是使用了最傳統的 Spring XML 的配置方式，幫助讀者理解。更高級的通過 annotation 甚至 spring boot 的方式，讀者可以自行查閱 Dubbo 和 Zipkin 相關的文檔。

  1. 暴露 HelloService 服務

    在 resouces/spring/hello-service.xml 中增加以下的配置來將 HelloServiceImpl 暴露成一個 Dubbo 服務：

    • 使用了本地啟動的 Zookeeper Server 作為註冊中心，地址為默認值 zookeeper://127.0.0.1:2181
    • 用 Dubbo 原生服務在端口 20880 上暴露服務
    • 將 HelloServiceImpl 註冊成 id 是 helloService 的 Spring Bean，這樣就可以在後續的 &lt;dubbo:service&gt; 中引用到這個實現類
    • 通過 &lt;dubbo:service&gt; 將 HelloServiceImpl 暴露成 Dubbo 服務
        <!-- 定義 HelloService 的應用名 -->
    <dubbo:application name="hello-service-provider"/>

    <!-- 指定註冊中心地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <!-- 使用 Dubbo 原生協議在 20880 端口上暴露服務 -->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!-- 將 HelloServiceImpl 的實現聲明成一個 spring bean -->
    <bean id="helloService" class="com.alibaba.dubbo.samples.service.hello.HelloServiceImpl"/>

    <!-- 將 HelloServiceImpl 聲明成一個 Dubbo 服務 -->
    <dubbo:service interface="com.alibaba.dubbo.samples.api.HelloService" ref="helloService"/>

  2. 增加 Zipkin 相關的配置

    在 resources/spring/hello-service.xml 中增加 Zipkin 相關的配置：

    • 修改 dubbo 服務暴露的配置，添加 Zipkin 的 tracing filter 到 Dubbo 的 filter chain 中
    • 按照 https://github.com/openzipkin/brave/blob/master/spring-beans/README.md 來配置 Zipkin 的 sender 和 tracing 的 spring bean
        <!-- 1. 修改 dubbo 服務暴露配置，在 filter chain 中增加 zipkin 的 tracing 過濾器 -->
    <dubbo:service interface="com.alibaba.dubbo.samples.api.HelloService" ref="helloService" filter="tracing"/>

    <!-- 2. zipkin 相關的配置 -->
    <!-- 使用 OKHttp 來發送 trace 信息到 Zipkin Server。這裏的 Zipkin Server 啟動在本地 -->
    <bean id="sender" class="zipkin2.reporter.beans.OkHttpSenderFactoryBean">
        <property name="endpoint" value="http://localhost:9411/api/v2/spans"/>
    </bean>

    <bean id="tracing" class="brave.spring.beans.TracingFactoryBean">
        <property name="localServiceName" value="hello-service"/>
        <property name="spanReporter">
            <bean class="zipkin2.reporter.beans.AsyncReporterFactoryBean">
                <property name="sender" ref="sender"/>
                <!-- wait up to half a second for any in-flight spans on close -->
                <property name="closeTimeout" value="500"/>
            </bean>
        </property>
        <property name="currentTraceContext">
            <bean class="brave.spring.beans.CurrentTraceContextFactoryBean">
                <property name="scopeDecorators">
                    <bean class="brave.context.slf4j.MDCScopeDecorator" factory-method="create"/>
                </property>
            </bean>
        </property>
    </bean>

  3. 增加 HelloService 的啟動類

    在 com.alibaba.dubbo.samples.service.hello.Application 中通過 ClassPathXmlApplicationContext 讀取 剛才配置的 spring/hello-service.xml 來初始化一個 spring context 並啟動

    package com.alibaba.dubbo.samples.service.hello;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

public class Application {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/hello-service.xml");
        context.start();

        System.out.println("Hello service started");
        // press any key to exit
        System.in.read();
    }
}

  4. 暴露 GreetingService 服務，並使用 Zipkin

    在 resources/spring/greeting-service.xml 中配置 GreetingService。相關步驟與 HelloService 類似，不再贅述，重點關註如何在 GreetingService 中配置下遊服務的依賴。完整的 XML 配置如下：

    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 1. 定義 GreetingService 的應用名 -->
    <dubbo:application name="greeting-service-provider"/>

    <!-- 2. 指定註冊中心地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

     <!-- 3. 使用 Dubbo 原生協議在 20881 端口上暴露服務 -->
    <dubbo:protocol name="dubbo" port="20881"/>

    <!-- 4. 聲明 HelloService 的遠程代理，並在 Dubbo 的 filter chain 中增加 tracing filter -->
    <dubbo:reference id="helloService" check="false" interface="com.alibaba.dubbo.samples.api.HelloService" filter="tracing"/>

    <!-- 5. 將 GreetingServiceImpl 的實現聲明成一個 spring bean，並將 HelloService 的遠程代理裝配進去 -->
    <bean id="greetingService" class="com.alibaba.dubbo.samples.service.greeting.GreetingServiceImpl">
        <property name="helloService" ref="helloService"/>
    </bean>

    <!-- 6. 將 GreetingServiceImpl 聲明成一個 Dubbo 服務，並在 Dubbo 的 filter chain 中增加 tracing filter -->
    <dubbo:service interface="com.alibaba.dubbo.samples.api.GreetingService" ref="greetingService" filter="tracing"/>

    <!-- 7. zipkin 相關的配置 -->
    <bean id="sender" class="zipkin2.reporter.beans.OkHttpSenderFactoryBean">
        <property name="endpoint" value="http://localhost:9411/api/v2/spans"/>
    </bean>

    <bean id="tracing" class="brave.spring.beans.TracingFactoryBean">
        <property name="localServiceName" value="greeting-service"/>
        <property name="spanReporter">
            <bean class="zipkin2.reporter.beans.AsyncReporterFactoryBean">
                <property name="sender" ref="sender"/>
                <!-- wait up to half a second for any in-flight spans on close -->
                <property name="closeTimeout" value="500"/>
            </bean>
        </property>
        <property name="currentTraceContext">
            <bean class="brave.spring.beans.CurrentTraceContextFactoryBean">
                <property name="scopeDecorators">
                    <bean class="brave.context.slf4j.MDCScopeDecorator" factory-method="create"/>
                </property>
            </bean>
        </property>
    </bean>
</beans>

    這裏的配置與上面的 HelloService 類似，需要重點關註的有兩點：

    • 第 3 步中註意服務需要暴露在不同的端口上，否則會和 HelloService 沖突，本例中選擇的是 20881 這個端口
    • 通過第 4 步先聲明 HelloService 的遠程代理，然後在第 5 步中將其組裝給 GreetingService 來完成服務上下遊依賴的聲明

    增加 GreeeingService 的啟動類，與 HelloService 類似，通過 spring/greeting-service.xml 的配置來初始化一個新的 spring context 來完成。

   package com.alibaba.dubbo.samples.service.greeting;

   import org.springframework.context.support.ClassPathXmlApplicationContext;

   import java.io.IOException;

   public class Application {
       public static void main(String[] args) throws IOException {
           ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/greeting-service.xml");
           context.start();

           System.out.println("Greeting service started");
           // press any key to exit
           System.in.read();
       }
   }

  1. 實現客戶端

    通過 resources/spring/client.xml 初始化一個 spring context，從其中獲取 GreetingService 的遠程代理，發起遠程調用。

    package com.alibaba.dubbo.samples.client;

import com.alibaba.dubbo.samples.api.GreetingService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Application {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/client.xml");
        context.start();
        // 獲取遠程代理並發起調用
        GreetingService greetingService = (GreetingService) context.getBean("greetingService");
        System.out.println(greetingService.greeting("world"));
    }
}

    resource/spring/client.xml 中的配置與 Dubbo 服務的配置類似，主要是配置遠程代理，以及配置 Zipkin

    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

   <!-- 1. 定義 dubbo 客戶端的應用名 -->
    <dubbo:application name="dubbo-client"/>

    <!-- 2. 指定註冊中心地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <!-- 3. 聲明 GreetingService 的遠程代理，並在 Dubbo 的 filter chain 中增加 tracing filter -->
    <dubbo:reference id="greetingService" check="false" interface="com.alibaba.dubbo.samples.api.GreetingService" filter="tracing"/>

    <!-- 4. zipkin 相關的配置 -->
    <bean id="sender" class="zipkin2.reporter.beans.OkHttpSenderFactoryBean">
        <property name="endpoint" value="http://localhost:9411/api/v2/spans"/>
    </bean>

    <bean id="tracing" class="brave.spring.beans.TracingFactoryBean">
        <property name="localServiceName" value="client"/>
        <property name="spanReporter">
            <bean class="zipkin2.reporter.beans.AsyncReporterFactoryBean">
                <property name="sender" ref="sender"/>
                <!-- wait up to half a second for any in-flight spans on close -->
                <property name="closeTimeout" value="500"/>
            </bean>
        </property>
        <property name="currentTraceContext">
            <bean class="brave.spring.beans.CurrentTraceContextFactoryBean">
                <property name="scopeDecorators">
                    <bean class="brave.context.slf4j.MDCScopeDecorator" factory-method="create"/>
                </property>
            </bean>
        </property>
    </bean>
</beans>

完成之後的工程的目錄結構如下：

技術分享圖片

運行

現在讓我們把整個鏈路運行起來，看看 Zipkin 鏈路追蹤的效果。

啟動 Zookeeper Server

執行以下命令在本地啟動一個 Zookeeper Server，如果沒有安裝，請自行從 ZooKeeper 官網 下載：

$ zkServer start

啟動 Zipkin Server

執行以下命令在本地啟動一個 Zipkin Server：

$ curl -sSL https://zipkin.io/quickstart.sh | bash -s
$ java -jar zipkin.jar

啟動 HelloService

使用下面的命令啟動 HelloService，當然也可以直接在 IDE 中啟動：

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.service.hello.Application

啟動成功後應該可以在終端上看到 “Hello service started” 的字樣。

啟動 GreetingService

使用下面的命令啟動 GreetingService，當然也可以直接在 IDE 中啟動：

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.service.greeting.Application

啟動成功後應該可以在終端上看到 “Greeting service started” 的字樣。

運行 Dubbo 客戶端

使用下面的命令運行 Dubbo 客戶端向 GreetingService 發起遠程調用，當然也可以直接在 IDE 中運行：

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.client.Application

執行成功後，客戶端會在終端上輸出 “greeting, hello, world”。

鏈路追蹤

打開瀏覽器訪問 "http://localhost:9411" 並通過 "Find Traces" 按鈕來搜索，可以找到剛剛調用的鏈路追蹤，效果如下圖所示：

技術分享圖片

還可以進一步的選擇每一個 span 來查看本次調用邊界內的詳情，比如，hello-service 這個 span 的詳情如下：

技術分享圖片

總結

本文介紹了鏈路追蹤的基本概念以及 Zipkin 的基本用法，然後用 Dubbo 構建了一條最簡單的調用鏈路，並引入了 Zipkin 做全鏈路追蹤。由於 Zipkin 對 Dubbo 做了很好的支持，整個集成的過程還是十分簡單明了的。

Zipkin 對 Dubbo 的支持是構建在 Dubbo 的 filter 擴展機制上的，有興趣的讀者可以通過 https://github.com/openzipkin/brave/blob/master/instrumentation/dubbo-rpc/src/main/java/brave/dubbo/rpc/TracingFilter.java 了解其實現細節。

本文中涉及的例子可以從 https://github.com/dubbo/dubbo-samples 中的 "dubbo-samples-zipkin" 子模塊中獲取。另外，spring-cloud-sleth 2.0 中開始 正式支持 Dubbo，相關的文章和例子後續計劃提供。

歡迎關註“阿裏巴巴中間件”，加入中間件開發者群，與技術同行。

技術分享圖片

服務化改造實踐（三） | Dubbo + Zipkin

相關推薦

服務化改造實踐（三） | Dubbo + Zipkin

next 另一個 興趣 hit scrip dep -bash find exception 隨著業務的發展，應用的規模不斷的擴大，傳統的應用架構無法滿足訴求，服務化架構改造勢在必行，以 Dubbo 為代表的分布式服務框架成為了服務化改造架構中的基石。隨著微服務理念逐漸被大

服務化改造實踐（一）| Dubbo + ZooKeeper

roo app 組織 mes false 部分 nba 進程 4.4 摘要： “沒有最好的技術，只有最合適的技術。”我想這句話也同樣適用於微服務領域，沒有最好的服務框架，只有最適合自己的服務改造。在 Dubbo 的未來規劃中，除了保持自身技術上的領先性，關註性能、大流量、大

服務化改造實踐（二）| Dubbo + Kubernetes

cover del ESS 運行 etc 資源 應用層 註冊中心 調用 摘要： “沒有最好的技術，只有最合適的技術。”我想這句話也同樣適用於微服務領域，沒有最好的服務框架，只有最適合自己的服務改造。在Dubbo的未來規劃中，除了保持自身技術上的領先性，關註性能，大流量，大規

disconf實踐（三）基於XML的分布式配置文件管理，自動reload

blog exce conf redis 信息 exceptio res pan ram 上一篇介紹了基於xml的非自動reload的分布式配置文件管理，這一篇介紹自動reload的方式（基於disconf實踐二）。 1. 修改RedisConfig.java 1 pa

Linux多線程實踐（三）線程的基本屬性設置API

ets evel 內核 system 範圍 ack jsb sig 溢出 POSIX 線程庫定義了線程屬性對象 pthread_attr_t ，它封裝了線程的創建者能夠訪問和改動的線程屬性。主要包含例如以下屬性： 1. 作用域（scope） 2. 棧尺寸（s

Kotlin學習與實踐 （三）fun 函數

意義 element 中間 類的方法 int prefix cal save tor 通過例子來學習如何高效的在Kotlin中定義使用函數。 1、命名參數、默認參數、頂層函數、擴展函數 * 展示幾種創建集合類的方法和擴展的簡單操作集合類的方法 fun createColl

Git工程開發實踐（三）——Git常用操作

file 歷史信息 ima 同步 其它 最新版本 指定 對象 revert Git工程開發實踐（三）——Git常用操作 一、Git倉庫操作 1、Git倉庫創建 git init在當前目錄中初始化Git倉庫git init [project-name]創建一個新目錄並初始化倉

mllib實踐（三）之LinearRegression實踐（libsvm方式）（整合網際網路上多個例項）

package mllib; import org.apache.spark.{ SparkConf, SparkContext } import org.apache.spark.ml.linalg.Vectors import org.apache.spark.mllib.regress

【百度】大型網站的HTTPS實踐（三）——HTTPS對效能的影響

HTTPS在保護使用者隱私，防止流量劫持方面發揮著非常關鍵的作用，但與此同時，HTTPS也會降低使用者訪問速度，增加網站伺服器的計算資源消耗。本文主要介紹HTTPS對效能的影響。 HTTPS對訪問速度的影響 在介紹速度優化策略之前，先來看下HTTPS對速度有什麼影響。影響主要來自兩方面：協議互動所增加的網

Service Worker學習與實踐（三）——訊息推送

在上一篇文章Service Worker學習與實踐（二）——PWA簡介中，已經講到PWA的起源，優勢與劣勢，並通過一個簡單的例子說明了如何在桌面端和移動端將一個PWA安裝到桌面上，這篇文章，將通過一個例子闡述如何使用Service Worker的訊息推送功能，並配合PWA技術，帶來原生應用般的訊息推送體驗。

EFK 配置geo-ip落地實踐（三）經緯度資料查詢及格式化輸出

經過之前的工作，目前已經完成了資料地圖的資料格式化和錄入記錄，目前我們的資料地圖專案已經進行到最後階段，所以現在需要一個介面，進行格式化資料並輸出，其中需要用到Elasticsearch的全文檢索，檢索出資料後，使用php介面格式化資料輸出 一、全文檢索 搜尋條件（時間，空間） 輸出結果（使用者

機器學習實踐（三）—sklearn之特徵工程

一、特徵工程介紹 1. 為什麼需要特徵工程 Andrew Ng ： “Coming up with features is difficult, time-consuming, requires expert knowledge. “Applied machine learnin

Spring Boot 最佳實踐（三）模板引擎FreeMarker整合

一、FreeMaker介紹 FreeMarker是一款免費的Java模板引擎，是一種基於模板和資料生成文字（HMLT、電子郵件、配置檔案、原始碼等）的工具，它不是面向終端使用者的，而是一款程式設計師使用的元件。 FreeMarker最初設計是用來在MVC模式的Web

SpringCloud入門最佳實踐（三）Rest微服務構建案例工程模組

介紹 承接著我們的springmvc+mybatis+mysql初級高階課程，以Dept部門模組做一個微服務通用案例Consumer消費（Client）通過REST呼叫Provider提供者（Serv

Docker實踐（三）容器

Docker中，容器是獨立執行的一個或一組應用，以及應用執行的環境；對應傳統的虛擬化，虛擬機器可以理解為模擬作業系統和執行在上面的應用。 啟動容器 啟動容器一般有兩種方式，一種是新建容器並啟動，一種是將終止狀態的容器重新啟動，Docker容器非常的輕量級，能夠很好的支援使

【MVC】.NET實踐（三）—對資料庫的資料進行刪除與修改

在主介面新增修改和刪除的超連結（Index.cshtml） <table id="tbList"> <tr> <th>id&l

Struts原理與實踐（三）

                一、JDBC的工作原理 Struts在本質上是java程式，要在Struts應用程式中訪問資料庫，首先，必須搞清楚Java Database Connectivity API(JDBC)的工作原理。正如其名字揭示的，JDBC庫提供了一個底層API，用來支援獨立於任何特定SQL實

Redis實踐（三）安裝第三方模組rejson

準備基礎環境 Centos7&&Ubuntu安裝git： sudo apt-get install build-essential #這是Ubuntu上的命令 yum g

基於 DevOps 的微服務生態系統與工程實踐（三）

作者簡介： 王磊 華為 中央軟體院首席軟體工程技術專家 國內首批 DevOps Master 認證講師，《DevOps Handbook》中文譯者。 並著有國內首本微服務架構相關書籍《微服務架構與實踐》一書。 前言 從2014年開始，當我接觸微服務之後，我發現在微服務的演進過程中，開發和測試、運維

RPC實踐（三）Hessian實踐

一、Hessian 簡介 Hessian是一種基於二進位制Web服務協議的RPC服務，它最大的特點是一個輕量級的框架，基於二進位制協議Binary-RPC，藉助http進行互動的遠端呼叫框架。因為它是一個二進位制協議，它非常適合於傳送二進位制資料，而無需任何需要擴充套件的協