OpenTelemetry、Spring Cloud Sleuth、Kafka、およびJaegerを使用した分散トレース

分散トレースは、特定のサービスが分散ソフトウェアシステム全体の一部としてどのように実行されているかについての洞察を提供します。発信元から宛先、および通過するシステムまでのリクエストを追跡および記録します。

この記事では、OpenTelemetry、Spring Cloud Sleuth、Kafka、およびJaegerを使用して、3つのSpringBootマイクロサービスに分散トレースを実装します。

まず、分散トレースの基本的な用語のいくつかを見てみましょう。

スパン:システム内の単一の作業単位を表します。スパンを相互にネストして、作業の分解をモデル化できます。たとえば、あるスパンがRESTエンドポイントを呼び出し、別の子スパンがそのエンドポイントが別のエンドポイントを呼び出すようにし、以下同様に別のサービスで行うことができます。

トレース:すべてが同じルートスパンを共有するスパンのコレクション、またはより単純に、元のリクエストの直接の結果として作成されたすべてのスパンを配置します。スパンの階層(それぞれがルートスパンに沿って独自の親スパンを持つ)を使用して、さまざまなコンポーネントを通過する際のリクエストのパスを示す有向非巡回グラフを作成できます。

OpenTelemetry

OpenTelemetryは、略してOTelとも呼ばれ、トレースメトリックログなどのテレメトリデータを計測、生成、収集、およびエクスポートするための、ベンダーに依存しないオープンソースの可観測性フレームワークです。Cloud Native Computing Foundation(CNCF)のインキュベーションプロジェクトとして、OTelは、主にデータを収集してどこかに転送するために、ベンダーに依存しないライブラリとAPIの統合セットを提供することを目指しています。OTelは、テレメトリデータを生成および管理するための世界標準になりつつあり、広く採用されています。

Spring Cloud Sleuth

Sleuthは、SpringBootアプリケーション内に分散トレース機能を統合することを目的としたSpringCloudチームによって管理および保守されているプロジェクトです。これは一般的なものとしてバンドルされているSpring Starterため、依存関係として追加するだけで、自動構成がアプリ全体のすべての統合とインストルメンテーションを処理します。すぐに使用できるSleuthインストゥルメントは次のとおりです。

  • Spring MVCコントローラー(RESTエンドポイント)で受信したリクエスト
  • KafkaやMQなどのメッセージングテクノロジーを介したリクエスト
  • RestTemplateWebClientなどで行われたリクエスト

Sleuthはインターセプターを追加して、すべてのトレース情報がリクエストで確実に渡されるようにします。呼び出しが行われるたびに、新しいスパンが作成されます。応答を受信すると閉じられます。

Sleuthはリクエストとメッセージを追跡できるため、その通信を対応するログエントリに関連付けることができます。トレース情報を外部システムにエクスポートして、遅延を視覚化することもできます。

イエーガー

Jaegerは元々Uberのチームによって構築され、2015年にオープンソースになりました。2017年にクラウドネイティブインキュベーションプロジェクトとして受け入れられ、2019年に卒業しました。CNCFの一部として、Jaegerはクラウドネイティブアーキテクチャで認められたプロジェクトです。そのソースコードは主にGoで書かれています。イエーガーのアーキテクチャには次のものが含まれます。

  • インストルメンテーションライブラリ
  • コレクター
  • クエリサービスとWebUI
  • データベースストレージ

Jaegerと同様に、Zipkinもそのアーキテクチャで同じコンポーネントのセットを提供します。Zipkinは古いプロジェクトですが、Jaegerはよりモダンでスケーラブルなデザインになっています。この例では、バックエンドとしてJaegerを選択しました。

トレースシステムの設計

3つのSpringBootマイクロサービスを設計しましょう。

  • customer-service-bffbackend for frontendパターンを使用して、このサービスはUIとバックエンドの間に配置されます。これはUIWebアプリによって呼び出され、UIWebアプリはRESTAPI呼び出しを介してバックエンドカスタマーサービスを呼び出します。
  • customer-service:シンプルなカスタマーCRUDサービス。CRUD操作時にデータベースにデータを保持するだけでなく、顧客レコードを作成、更新、または削除するときにイベントをKafkaに公開します。
  • order-service:Kafkaトピックをリッスンし、顧客が作成/更新/削除したイベントを消費します。

3つのマイクロサービスは次のように設計されています。

  • REST APIを介して通信する(customer-service-bffおよびcustomer-service
  • customer-serviceKafka(およびorder-service)を介したイベント駆動型のpub/subを介した通信

これは、OpenTelemetryとSpring Cloud Sleuthを組み合わせて、コードの自動インストルメンテーションを処理し、トレースデータを生成して送信する方法を観察するためのものです。上記の点線は、マイクロサービスによってエクスポートされたトレースデータのパスをキャプチャし、OTLP(OpenTelemetry Line Protocol)を介してOpenTelemetry Collectorに移動し、コレクターはトレースデータを処理してバックエンドJaegerにエクスポートし、保存してクエリを実行します。

モノレポを使用すると、次のようなプロジェクト構造になります。

ステップ1:POMの依存関係を追加する

これは、OTelとSpringCloudSleuthを使用して分散トレースを実装するための鍵です。私たちの目標は、コードを手動でインストルメントする必要がないため、これらの依存関係に依存して、設計されていることを実行します。実装のトレースに加えて、コードの自動インストルメンテーション、テレメトリデータのOTelコレクターへのエクスポートなどです。


<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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-otel-dependencies</artifactId>
            <version>${spring-cloud-sleuth-otel.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-sleuth-brave</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-otel-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-exporter-otlp-trace</artifactId>
    </dependency>
</dependencies>
  • spring-cloud-dependencies:SpringCloudの依存関係
  • spring-cloud-sleuth-otel-dependencies:Spring CloudSleuthOpenTelemetryの依存関係
  • spring-cloud-starter-sleuth:Sleuthは、モジュールで使用可能なブリッジを介してOpenZipkinBraveトレーサーと統合されspring-cloud-sleuth-braveます。バックエンドにZipkinを使用していないため、依存関係から除外spring-cloud-sleuth-braveし、spring-cloud-starter-sleuth代わりに依存関係を追加する必要がありspring-cloud-sleuth-otel-autoconfigureます。これにより、 Braveに基づくデフォルトのトレース実装がOpenTelemetryに基づく実装に置き換えられます。
  • opentelemetry-exporter-otlp-trace:これは、OpenTelemetryCollectorにトレースを送信するSpringCloudSleuthOTelのコンポーネントです。

ステップ2:OpenTelemetryの構成

OpenTelemetryCollectorエンドポイント

マイクロサービスごとに、次の構成をに追加する必要がありますapplication.yml(以下のセクションのサンプルスニペットを参照)。spring.sleuth.otel.exporter.otlp.endpoint主にOTelCollectorエンドポイントを構成するためのものです。これは、エクスポーター(この場合はSleuth)に、OTLPを介して指定されたコレクターエンドポイントにトレースデータを送信するように指示しますhttp://otel-collector:4317。エンドポイントURLの通知otel-collectorは、画像のdocker-composeサービスからのotel-collectorものです。

データ確率サンプリングのトレース

spring.sleuth.otel.config.trace-id-ratio-basedプロパティは、トレースデータのサンプリング確率を定義します。サンプラーに与えられたフラクションに基づいて、トレースのフラクションをサンプリングします。確率サンプリングにより、OpenTelemetryトレースのユーザーは、ランダム化されたサンプリング手法を使用してスパン収集コストを削減できます。比率が1.0未満の場合、一部のトレースはエクスポートされません。この例では、サンプリングを1.0、100%に構成します。

その他のOTelSpringCloud Sleuthプロパティについては、一般的なアプリケーションプロパティを参照してください。

spring:
  application:
    name: customer-service
  sleuth:
    otel:
      config:
        trace-id-ratio-based: 1.0
      exporter:
        otlp:
          endpoint: http://otel-collector:4317

OpenTelemetry構成ファイル

otel-config.yamlプロジェクトルートにOTel構成ファイルが必要です。内容は以下の通りです。この構成ファイルは、OTelレシーバー、プロセッサー、およびエクスポーターの動作を定義します。ご覧のとおり、gRPCとHTTPでリッスンするようにレシーバーを定義し、バッチとエクスポーターをイェーガーとロギングとして使用するプロセッサーを定義しました。

extensions:
  memory_ballast:
    size_mib: 512
  zpages:
    endpoint: 0.0.0.0:55679

receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:

exporters:
  logging:
    logLevel: debug
  jaeger:
    endpoint: jaeger-all-in-one:14250
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [ otlp ]
      processors: [ batch ]
      exporters: [ logging, jaeger ]
  extensions: [ memory_ballast, zpages ]

ステップ3:docker-すべて一緒に文字列を作成する

これらの3つのマイクロサービスを実行して分散トレースを観察するためにスピンアップする必要のあるDockerコンテナーを見てみましょう。最初の3つのマイクロサービスについては、上記のセクションで説明しています。

  • customer-service-bff
  • customer-service
  • order-service
  • postgres-customer:データベースcustomer-service
  • postgres-order:データベースorder-service
  • jaeger-all-in-one:すべてのJaegerバックエンドコンポーネントとUIを実行する単一のイメージ
  • otel-collector:OpenTelemetryトレースのエンジンであり、トレースデータを受信、処理、およびバックエンドにエクスポートします
  • zookeeper:Kafkaクラスター内のノードのステータスを追跡し、Kafkaトピックとメッセージのリストを維持します
  • kafka:pub/subイベントストリーミング処理プラットフォーム
services:

  customer-service-bff:
    image: customer-service-bff:0.0.1-SNAPSHOT
    ports:
      - "8080:8080"
    depends_on:
      - zookeeper
      - kafka

  customer-service:
    image: customer-service:0.0.1-SNAPSHOT
    ports:
      - "8081:8081"
    depends_on:
      - zookeeper
      - kafka
      - postgres-customer
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-customer:5432/customerservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  order-service:
    image: order-service:0.0.1-SNAPSHOT
    ports:
      - "8082:8082"
    depends_on:
      - zookeeper
      - kafka
      - postgres-order
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-order:5432/orderservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  postgres-customer:
    image: postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=customerservice

  postgres-order:
    image: postgres
    ports:
      - "5431:5431"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=orderservice

  jaeger-all-in-one:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"
      - "14268"
      - "14250"

  otel-collector:
    image: otel/opentelemetry-collector:0.47.0
    command: [ "--config=/etc/otel-collector-config.yaml" ]
    volumes:
      - ./otel-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "1888:1888"   # pprof extension
      - "13133:13133" # health_check extension
      - "4317"        # OTLP gRPC receiver
      - "55670:55679" # zpages extension
    depends_on:
      - jaeger-all-in-one

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

docker-compose up -d9つのコンテナすべてを起動するために実行します。

ステップ4:実際のデータのトレース

ハッピーパス

customer-service-bffそれでは、フローへのエントリポイントであるを起動して、新しい顧客を作成しましょう。

Jaeger UIを起動し、サービスhttp://localhost:16686/検索し、ボタンcustomer-service-bffをクリックしFind Tracesます。これが、顧客トレースの作成で表示されるものです。これは、3つのサービスにまたがり、合計で6にまたがり、期間は82.35ミリ秒です。

トレースタイムラインビュー(上のスクリーンショット)に加えて、イエーガーはグラフビュー(Trace Graph右上のドロップダウンで選択)も提供します。

3つのマイクロサービスのDockerのログ出力には、同じトレースIDが赤で強調表示され、アプリ名に応じてスパンIDが異なります(アプリケーション名と対応するスパンIDは一致する色で強調表示されます)。の場合customer-service、同じスパンIDがRESTAPIリクエストからKafkaパブリッシャーリクエストに渡されます。

エラーシナリオ

customer-serviceDockerでPostgreSQLデータベースを一時停止し、から顧客の作成フローを繰り返しますcustomer-service-bff500 internal server errorさすがに手に入れた。Jaegerをチェックインすると、次のトレースが表示されますが、例外のstacktraceがSocketTimeoutException、再び予想どおりに文句を言っています。

長期的なスパンの特定

Jaeger UIを使用すると、指定した最大期間よりも長いトレースを検索できます。たとえば、1000ミリ秒より長くかかったすべてのトレースを検索できます。次に、長時間実行されているトレースにドリルダウンして、それらの根本原因を調査できます。

概要

このストーリーでは、OpenTelemetry、Spring Cloud Sleuth、およびJaegerのレンズで分散トレースを解凍し、RESTAPI呼び出しとKafkapub/subの両方で分散トレースの自動インストルメンテーションを検証しました。このストーリーが、これらのトレースフレームワークとツール、特にOpenTelemetryについての理解を深め、分散システムでの可観測性の方法を根本的に変える方法を理解してくれることを願っています。

このストーリーのソースコードは、私のGitHubリポジトリにあります。

ハッピーコーディング!

このストーリーは、もともとhttps://betterprogramming.pub/distributed-tracing-with-opentelemetry-spring-cloud-sleuth-kafka-and-jaeger-939e35f45821で公開されました

#jaeger #opentelemetry #spring #cloud #kafka 

What is GEEK

Buddha Community

OpenTelemetry、Spring Cloud Sleuth、Kafka、およびJaegerを使用した分散トレース

Enhance Amazon Aurora Read/Write Capability with ShardingSphere-JDBC

1. Introduction

Amazon Aurora is a relational database management system (RDBMS) developed by AWS(Amazon Web Services). Aurora gives you the performance and availability of commercial-grade databases with full MySQL and PostgreSQL compatibility. In terms of high performance, Aurora MySQL and Aurora PostgreSQL have shown an increase in throughput of up to 5X over stock MySQL and 3X over stock PostgreSQL respectively on similar hardware. In terms of scalability, Aurora achieves enhancements and innovations in storage and computing, horizontal and vertical functions.

Aurora supports up to 128TB of storage capacity and supports dynamic scaling of storage layer in units of 10GB. In terms of computing, Aurora supports scalable configurations for multiple read replicas. Each region can have an additional 15 Aurora replicas. In addition, Aurora provides multi-primary architecture to support four read/write nodes. Its Serverless architecture allows vertical scaling and reduces typical latency to under a second, while the Global Database enables a single database cluster to span multiple AWS Regions in low latency.

Aurora already provides great scalability with the growth of user data volume. Can it handle more data and support more concurrent access? You may consider using sharding to support the configuration of multiple underlying Aurora clusters. To this end, a series of blogs, including this one, provides you with a reference in choosing between Proxy and JDBC for sharding.

1.1 Why sharding is needed

AWS Aurora offers a single relational database. Primary-secondary, multi-primary, and global database, and other forms of hosting architecture can satisfy various architectural scenarios above. However, Aurora doesn’t provide direct support for sharding scenarios, and sharding has a variety of forms, such as vertical and horizontal forms. If we want to further increase data capacity, some problems have to be solved, such as cross-node database Join, associated query, distributed transactions, SQL sorting, page turning, function calculation, database global primary key, capacity planning, and secondary capacity expansion after sharding.

1.2 Sharding methods

It is generally accepted that when the capacity of a MySQL table is less than 10 million, the time spent on queries is optimal because at this time the height of its BTREE index is between 3 and 5. Data sharding can reduce the amount of data in a single table and distribute the read and write loads to different data nodes at the same time. Data sharding can be divided into vertical sharding and horizontal sharding.

1. Advantages of vertical sharding

  • Address the coupling of business system and make clearer.
  • Implement hierarchical management, maintenance, monitoring, and expansion to data of different businesses, like micro-service governance.
  • In high concurrency scenarios, vertical sharding removes the bottleneck of IO, database connections, and hardware resources on a single machine to some extent.

2. Disadvantages of vertical sharding

  • After splitting the library, Join can only be implemented by interface aggregation, which will increase the complexity of development.
  • After splitting the library, it is complex to process distributed transactions.
  • There is a large amount of data on a single table and horizontal sharding is required.

3. Advantages of horizontal sharding

  • There is no such performance bottleneck as a large amount of data on a single database and high concurrency, and it increases system stability and load capacity.
  • The business modules do not need to be split due to minor modification on the application client.

4. Disadvantages of horizontal sharding

  • Transaction consistency across shards is hard to be guaranteed;
  • The performance of associated query in cross-library Join is poor.
  • It’s difficult to scale the data many times and maintenance is a big workload.

Based on the analysis above, and the available studis on popular sharding middleware, we selected ShardingSphere, an open source product, combined with Amazon Aurora to introduce how the combination of these two products meets various forms of sharding and how to solve the problems brought by sharding.

ShardingSphere is an open source ecosystem including a set of distributed database middleware solutions, including 3 independent products, Sharding-JDBC, Sharding-Proxy & Sharding-Sidecar.

2. ShardingSphere introduction:

The characteristics of Sharding-JDBC are:

  1. With the client end connecting directly to the database, it provides service in the form of jar and requires no extra deployment and dependence.
  2. It can be considered as an enhanced JDBC driver, which is fully compatible with JDBC and all kinds of ORM frameworks.
  3. Applicable in any ORM framework based on JDBC, such as JPA, Hibernate, Mybatis, Spring JDBC Template or direct use of JDBC.
  4. Support any third-party database connection pool, such as DBCP, C3P0, BoneCP, Druid, HikariCP;
  5. Support any kind of JDBC standard database: MySQL, Oracle, SQLServer, PostgreSQL and any databases accessible to JDBC.
  6. Sharding-JDBC adopts decentralized architecture, applicable to high-performance light-weight OLTP application developed with Java

Hybrid Structure Integrating Sharding-JDBC and Applications

Sharding-JDBC’s core concepts

Data node: The smallest unit of a data slice, consisting of a data source name and a data table, such as ds_0.product_order_0.

Actual table: The physical table that really exists in the horizontal sharding database, such as product order tables: product_order_0, product_order_1, and product_order_2.

Logic table: The logical name of the horizontal sharding databases (tables) with the same schema. For instance, the logic table of the order product_order_0, product_order_1, and product_order_2 is product_order.

Binding table: It refers to the primary table and the joiner table with the same sharding rules. For example, product_order table and product_order_item are sharded by order_id, so they are binding tables with each other. Cartesian product correlation will not appear in the multi-tables correlating query, so the query efficiency will increase greatly.

Broadcast table: It refers to tables that exist in all sharding database sources. The schema and data must consist in each database. It can be applied to the small data volume that needs to correlate with big data tables to query, dictionary table and configuration table for example.

3. Testing ShardingSphere-JDBC

3.1 Example project

Download the example project code locally. In order to ensure the stability of the test code, we choose shardingsphere-example-4.0.0 version.

git clone https://github.com/apache/shardingsphere-example.git

Project description:

shardingsphere-example
  ├── example-core
  │   ├── config-utility
  │   ├── example-api
  │   ├── example-raw-jdbc
  │   ├── example-spring-jpa #spring+jpa integration-based entity,repository
  │   └── example-spring-mybatis
  ├── sharding-jdbc-example
  │   ├── sharding-example
  │   │   ├── sharding-raw-jdbc-example
  │   │   ├── sharding-spring-boot-jpa-example #integration-based sharding-jdbc functions
  │   │   ├── sharding-spring-boot-mybatis-example
  │   │   ├── sharding-spring-namespace-jpa-example
  │   │   └── sharding-spring-namespace-mybatis-example
  │   ├── orchestration-example
  │   │   ├── orchestration-raw-jdbc-example
  │   │   ├── orchestration-spring-boot-example #integration-based sharding-jdbc governance function
  │   │   └── orchestration-spring-namespace-example
  │   ├── transaction-example
  │   │   ├── transaction-2pc-xa-example #sharding-jdbc sample of two-phase commit for a distributed transaction
  │   │   └──transaction-base-seata-example #sharding-jdbc distributed transaction seata sample
  │   ├── other-feature-example
  │   │   ├── hint-example
  │   │   └── encrypt-example
  ├── sharding-proxy-example
  │   └── sharding-proxy-boot-mybatis-example
  └── src/resources
        └── manual_schema.sql  

Configuration file description:

application-master-slave.properties #read/write splitting profile
application-sharding-databases-tables.properties #sharding profile
application-sharding-databases.properties       #library split profile only
application-sharding-master-slave.properties    #sharding and read/write splitting profile
application-sharding-tables.properties          #table split profile
application.properties                         #spring boot profile

Code logic description:

The following is the entry class of the Spring Boot application below. Execute it to run the project.

The execution logic of demo is as follows:

3.2 Verifying read/write splitting

As business grows, the write and read requests can be split to different database nodes to effectively promote the processing capability of the entire database cluster. Aurora uses a reader/writer endpoint to meet users' requirements to write and read with strong consistency, and a read-only endpoint to meet the requirements to read without strong consistency. Aurora's read and write latency is within single-digit milliseconds, much lower than MySQL's binlog-based logical replication, so there's a lot of loads that can be directed to a read-only endpoint.

Through the one primary and multiple secondary configuration, query requests can be evenly distributed to multiple data replicas, which further improves the processing capability of the system. Read/write splitting can improve the throughput and availability of system, but it can also lead to data inconsistency. Aurora provides a primary/secondary architecture in a fully managed form, but applications on the upper-layer still need to manage multiple data sources when interacting with Aurora, routing SQL requests to different nodes based on the read/write type of SQL statements and certain routing policies.

ShardingSphere-JDBC provides read/write splitting features and it is integrated with application programs so that the complex configuration between application programs and database clusters can be separated from application programs. Developers can manage the Shard through configuration files and combine it with ORM frameworks such as Spring JPA and Mybatis to completely separate the duplicated logic from the code, which greatly improves the ability to maintain code and reduces the coupling between code and database.

3.2.1 Setting up the database environment

Create a set of Aurora MySQL read/write splitting clusters. The model is db.r5.2xlarge. Each set of clusters has one write node and two read nodes.

3.2.2 Configuring Sharding-JDBC

application.properties spring boot Master profile description:

You need to replace the green ones with your own environment configuration.

# Jpa automatically creates and drops data tables based on entities
spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.show_sql=true

#spring.profiles.active=sharding-databases
#spring.profiles.active=sharding-tables
#spring.profiles.active=sharding-databases-tables
#Activate master-slave configuration item so that sharding-jdbc can use master-slave profile
spring.profiles.active=master-slave
#spring.profiles.active=sharding-master-slave

application-master-slave.properties sharding-jdbc profile description:

spring.shardingsphere.datasource.names=ds_master,ds_slave_0,ds_slave_1
# data souce-master
spring.shardingsphere.datasource.ds_master.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master.password=Your master DB password
spring.shardingsphere.datasource.ds_master.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master.jdbc-url=Your primary DB data sourceurl spring.shardingsphere.datasource.ds_master.username=Your primary DB username
# data source-slave
spring.shardingsphere.datasource.ds_slave_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_slave_0.password= Your slave DB password
spring.shardingsphere.datasource.ds_slave_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_slave_0.jdbc-url=Your slave DB data source url
spring.shardingsphere.datasource.ds_slave_0.username= Your slave DB username
# data source-slave
spring.shardingsphere.datasource.ds_slave_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_slave_1.password= Your slave DB password
spring.shardingsphere.datasource.ds_slave_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_slave_1.jdbc-url= Your slave DB data source url
spring.shardingsphere.datasource.ds_slave_1.username= Your slave DB username
# Routing Policy Configuration
spring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin
spring.shardingsphere.masterslave.name=ds_ms
spring.shardingsphere.masterslave.master-data-source-name=ds_master
spring.shardingsphere.masterslave.slave-data-source-names=ds_slave_0,ds_slave_1
# sharding-jdbc configures the information storage mode
spring.shardingsphere.mode.type=Memory
# start shardingsphere log,and you can see the conversion from logical SQL to actual SQL from the print
spring.shardingsphere.props.sql.show=true

 

3.2.3 Test and verification process description

  • Test environment data initialization: Spring JPA initialization automatically creates tables for testing.

  • Write data to the master instance

As shown in the ShardingSphere-SQL log figure below, the write SQL is executed on the ds_master data source.

  • Data query operations are performed on the slave library.

As shown in the ShardingSphere-SQL log figure below, the read SQL is executed on the ds_slave data source in the form of polling.

[INFO ] 2022-04-02 19:43:39,376 --main-- [ShardingSphere-SQL] Rule Type: master-slave 
[INFO ] 2022-04-02 19:43:39,376 --main-- [ShardingSphere-SQL] SQL: select orderentit0_.order_id as order_id1_1_, orderentit0_.address_id as address_2_1_, 
orderentit0_.status as status3_1_, orderentit0_.user_id as user_id4_1_ from t_order orderentit0_ ::: DataSources: ds_slave_0 
---------------------------- Print OrderItem Data -------------------
Hibernate: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, orderiteme1_.user_id 
as user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id
[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] Rule Type: master-slave 
[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] SQL: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, 
orderiteme1_.user_id as user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id ::: DataSources: ds_slave_1 

Note: As shown in the figure below, if there are both reads and writes in a transaction, Sharding-JDBC routes both read and write operations to the master library. If the read/write requests are not in the same transaction, the corresponding read requests are distributed to different read nodes according to the routing policy.

@Override
@Transactional // When a transaction is started, both read and write in the transaction go through the master library. When closed, read goes through the slave library and write goes through the master library
public void processSuccess() throws SQLException {
    System.out.println("-------------- Process Success Begin ---------------");
    List<Long> orderIds = insertData();
    printData();
    deleteData(orderIds);
    printData();
    System.out.println("-------------- Process Success Finish --------------");
}

3.2.4 Verifying Aurora failover scenario

The Aurora database environment adopts the configuration described in Section 2.2.1.

3.2.4.1 Verification process description

  1. Start the Spring-Boot project

2. Perform a failover on Aurora’s console

3. Execute the Rest API request

4. Repeatedly execute POST (http://localhost:8088/save-user) until the call to the API failed to write to Aurora and eventually recovered successfully.

5. The following figure shows the process of executing code failover. It takes about 37 seconds from the time when the latest SQL write is successfully performed to the time when the next SQL write is successfully performed. That is, the application can be automatically recovered from Aurora failover, and the recovery time is about 37 seconds.

3.3 Testing table sharding-only function

3.3.1 Configuring Sharding-JDBC

application.properties spring boot master profile description

# Jpa automatically creates and drops data tables based on entities
spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.show_sql=true
#spring.profiles.active=sharding-databases
#Activate sharding-tables configuration items
#spring.profiles.active=sharding-tables
#spring.profiles.active=sharding-databases-tables
# spring.profiles.active=master-slave
#spring.profiles.active=sharding-master-slave

application-sharding-tables.properties sharding-jdbc profile description

## configure primary-key policy
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123
# configure the binding relation of t_order and t_order_item
spring.shardingsphere.sharding.binding-tables[0]=t_order,t_order_item
# configure broadcast tables
spring.shardingsphere.sharding.broadcast-tables=t_address
# sharding-jdbc mode
spring.shardingsphere.mode.type=Memory
# start shardingsphere log
spring.shardingsphere.props.sql.show=true

 

3.3.2 Test and verification process description

1. DDL operation

JPA automatically creates tables for testing. When Sharding-JDBC routing rules are configured, the client executes DDL, and Sharding-JDBC automatically creates corresponding tables according to the table splitting rules. If t_address is a broadcast table, create a t_address because there is only one master instance. Two physical tables t_order_0 and t_order_1 will be created when creating t_order.

2. Write operation

As shown in the figure below, Logic SQL inserts a record into t_order. When Sharding-JDBC is executed, data will be distributed to t_order_0 and t_order_1 according to the table splitting rules.

When t_order and t_order_item are bound, the records associated with order_item and order are placed on the same physical table.

3. Read operation

As shown in the figure below, perform the join query operations to order and order_item under the binding table, and the physical shard is precisely located based on the binding relationship.

The join query operations on order and order_item under the unbound table will traverse all shards.

3.4 Testing database sharding-only function

3.4.1 Setting up the database environment

Create two instances on Aurora: ds_0 and ds_1

When the sharding-spring-boot-jpa-example project is started, tables t_order, t_order_itemt_address will be created on two Aurora instances.

3.4.2 Configuring Sharding-JDBC

application.properties springboot master profile description

# Jpa automatically creates and drops data tables based on entities
spring.jpa.properties.hibernate.hbm2ddl.auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.show_sql=true

# Activate sharding-databases configuration items
spring.profiles.active=sharding-databases
#spring.profiles.active=sharding-tables
#spring.profiles.active=sharding-databases-tables
#spring.profiles.active=master-slave
#spring.profiles.active=sharding-master-slave

application-sharding-databases.properties sharding-jdbc profile description

spring.shardingsphere.datasource.names=ds_0,ds_1
# ds_0
spring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_0.jdbc-url= spring.shardingsphere.datasource.ds_0.username= 
spring.shardingsphere.datasource.ds_0.password=
# ds_1
spring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_1.jdbc-url= 
spring.shardingsphere.datasource.ds_1.username= 
spring.shardingsphere.datasource.ds_1.password=
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address
spring.shardingsphere.sharding.default-data-source-name=ds_0

spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_$->{0..1}.t_order
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_$->{0..1}.t_order_item
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123
# sharding-jdbc mode
spring.shardingsphere.mode.type=Memory
# start shardingsphere log
spring.shardingsphere.props.sql.show=true

 

3.4.3 Test and verification process description

1. DDL operation

JPA automatically creates tables for testing. When Sharding-JDBC’s library splitting and routing rules are configured, the client executes DDL, and Sharding-JDBC will automatically create corresponding tables according to table splitting rules. If t_address is a broadcast table, physical tables will be created on ds_0 and ds_1. The three tables, t_address, t_order and t_order_item will be created on ds_0 and ds_1 respectively.

2. Write operation

For the broadcast table t_address, each record written will also be written to the t_address tables of ds_0 and ds_1.

The tables t_order and t_order_item of the slave library are written on the table in the corresponding instance according to the slave library field and routing policy.

3. Read operation

Query order is routed to the corresponding Aurora instance according to the routing rules of the slave library .

Query Address. Since address is a broadcast table, an instance of address will be randomly selected and queried from the nodes used.

As shown in the figure below, perform the join query operations to order and order_item under the binding table, and the physical shard is precisely located based on the binding relationship.

3.5 Verifying sharding function

3.5.1 Setting up the database environment

As shown in the figure below, create two instances on Aurora: ds_0 and ds_1

When the sharding-spring-boot-jpa-example project is started, physical tables t_order_01, t_order_02, t_order_item_01,and t_order_item_02 and global table t_address will be created on two Aurora instances.

3.5.2 Configuring Sharding-JDBC

application.properties springboot master profile description

# Jpa automatically creates and drops data tables based on entities
spring.jpa.properties.hibernate.hbm2ddl.auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.show_sql=true
# Activate sharding-databases-tables configuration items
#spring.profiles.active=sharding-databases
#spring.profiles.active=sharding-tables
spring.profiles.active=sharding-databases-tables
#spring.profiles.active=master-slave
#spring.profiles.active=sharding-master-slave

application-sharding-databases.properties sharding-jdbc profile description

spring.shardingsphere.datasource.names=ds_0,ds_1
# ds_0
spring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_0.jdbc-url= 306/dev?useSSL=false&characterEncoding=utf-8
spring.shardingsphere.datasource.ds_0.username= 
spring.shardingsphere.datasource.ds_0.password=
spring.shardingsphere.datasource.ds_0.max-active=16
# ds_1
spring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_1.jdbc-url= 
spring.shardingsphere.datasource.ds_1.username= 
spring.shardingsphere.datasource.ds_1.password=
spring.shardingsphere.datasource.ds_1.max-active=16
# default library splitting policy
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address
# Tables that do not meet the library splitting policy are placed on ds_0
spring.shardingsphere.sharding.default-data-source-name=ds_0
# t_order table splitting policy
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_$->{0..1}.t_order_$->{0..1}
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
# t_order_item table splitting policy
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_$->{0..1}.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123
# sharding-jdbc mdoe
spring.shardingsphere.mode.type=Memory
# start shardingsphere log
spring.shardingsphere.props.sql.show=true

 

3.5.3 Test and verification process description

1. DDL operation

JPA automatically creates tables for testing. When Sharding-JDBC’s sharding and routing rules are configured, the client executes DDL, and Sharding-JDBC will automatically create corresponding tables according to table splitting rules. If t_address is a broadcast table, t_address will be created on both ds_0 and ds_1. The three tables, t_address, t_order and t_order_item will be created on ds_0 and ds_1 respectively.

2. Write operation

For the broadcast table t_address, each record written will also be written to the t_address tables of ds_0 and ds_1.

The tables t_order and t_order_item of the sub-library are written to the table on the corresponding instance according to the slave library field and routing policy.

3. Read operation

The read operation is similar to the library split function verification described in section2.4.3.

3.6 Testing database sharding, table sharding and read/write splitting function

3.6.1 Setting up the database environment

The following figure shows the physical table of the created database instance.

3.6.2 Configuring Sharding-JDBC

application.properties spring boot master profile description

# Jpa automatically creates and drops data tables based on entities
spring.jpa.properties.hibernate.hbm2ddl.auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.show_sql=true

# activate sharding-databases-tables configuration items
#spring.profiles.active=sharding-databases
#spring.profiles.active=sharding-tables
#spring.profiles.active=sharding-databases-tables
#spring.profiles.active=master-slave
spring.profiles.active=sharding-master-slave

application-sharding-master-slave.properties sharding-jdbc profile description

The url, name and password of the database need to be changed to your own database parameters.

spring.shardingsphere.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1
spring.shardingsphere.datasource.ds_master_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0.username= 
spring.shardingsphere.datasource.ds_master_0.password=
spring.shardingsphere.datasource.ds_master_0.max-active=16
spring.shardingsphere.datasource.ds_master_0_slave_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_0_slave_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_0_slave_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_0.username= 
spring.shardingsphere.datasource.ds_master_0_slave_0.password=
spring.shardingsphere.datasource.ds_master_0_slave_0.max-active=16
spring.shardingsphere.datasource.ds_master_0_slave_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_0_slave_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_0_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_1.username= 
spring.shardingsphere.datasource.ds_master_0_slave_1.password=
spring.shardingsphere.datasource.ds_master_0_slave_1.max-active=16
spring.shardingsphere.datasource.ds_master_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_1.jdbc-url= 
spring.shardingsphere.datasource.ds_master_1.username= 
spring.shardingsphere.datasource.ds_master_1.password=
spring.shardingsphere.datasource.ds_master_1.max-active=16
spring.shardingsphere.datasource.ds_master_1_slave_0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_1_slave_0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_1_slave_0.jdbc-url=
spring.shardingsphere.datasource.ds_master_1_slave_0.username=
spring.shardingsphere.datasource.ds_master_1_slave_0.password=
spring.shardingsphere.datasource.ds_master_1_slave_0.max-active=16
spring.shardingsphere.datasource.ds_master_1_slave_1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds_master_1_slave_1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds_master_1_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_1_slave_1.username=admin
spring.shardingsphere.datasource.ds_master_1_slave_1.password=
spring.shardingsphere.datasource.ds_master_1_slave_1.max-active=16
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address
spring.shardingsphere.sharding.default-data-source-name=ds_master_0
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_$->{0..1}.t_order_$->{0..1}
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_$->{0..1}.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123
# master/slave data source and slave data source configuration
spring.shardingsphere.sharding.master-slave-rules.ds_0.master-data-source-name=ds_master_0
spring.shardingsphere.sharding.master-slave-rules.ds_0.slave-data-source-names=ds_master_0_slave_0, ds_master_0_slave_1
spring.shardingsphere.sharding.master-slave-rules.ds_1.master-data-source-name=ds_master_1
spring.shardingsphere.sharding.master-slave-rules.ds_1.slave-data-source-names=ds_master_1_slave_0, ds_master_1_slave_1
# sharding-jdbc mode
spring.shardingsphere.mode.type=Memory
# start shardingsphere log
spring.shardingsphere.props.sql.show=true

 

3.6.3 Test and verification process description

1. DDL operation

JPA automatically creates tables for testing. When Sharding-JDBC’s library splitting and routing rules are configured, the client executes DDL, and Sharding-JDBC will automatically create corresponding tables according to table splitting rules. If t_address is a broadcast table, t_address will be created on both ds_0 and ds_1. The three tables, t_address, t_order and t_order_item will be created on ds_0 and ds_1 respectively.

2. Write operation

For the broadcast table t_address, each record written will also be written to the t_address tables of ds_0 and ds_1.

The tables t_order and t_order_item of the slave library are written to the table on the corresponding instance according to the slave library field and routing policy.

3. Read operation

The join query operations on order and order_item under the binding table are shown below.

3. Conclusion

As an open source product focusing on database enhancement, ShardingSphere is pretty good in terms of its community activitiy, product maturity and documentation richness.

Among its products, ShardingSphere-JDBC is a sharding solution based on the client-side, which supports all sharding scenarios. And there’s no need to introduce an intermediate layer like Proxy, so the complexity of operation and maintenance is reduced. Its latency is theoretically lower than Proxy due to the lack of intermediate layer. In addition, ShardingSphere-JDBC can support a variety of relational databases based on SQL standards such as MySQL/PostgreSQL/Oracle/SQL Server, etc.

However, due to the integration of Sharding-JDBC with the application program, it only supports Java language for now, and is strongly dependent on the application programs. Nevertheless, Sharding-JDBC separates all sharding configuration from the application program, which brings relatively small changes when switching to other middleware.

In conclusion, Sharding-JDBC is a good choice if you use a Java-based system and have to to interconnect with different relational databases — and don’t want to bother with introducing an intermediate layer.

Author

Sun Jinhua

A senior solution architect at AWS, Sun is responsible for the design and consult on cloud architecture. for providing customers with cloud-related design and consulting services. Before joining AWS, he ran his own business, specializing in building e-commerce platforms and designing the overall architecture for e-commerce platforms of automotive companies. He worked in a global leading communication equipment company as a senior engineer, responsible for the development and architecture design of multiple subsystems of LTE equipment system. He has rich experience in architecture design with high concurrency and high availability system, microservice architecture design, database, middleware, IOT etc.

Adaline  Kulas

Adaline Kulas

1594162500

Multi-cloud Spending: 8 Tips To Lower Cost

A multi-cloud approach is nothing but leveraging two or more cloud platforms for meeting the various business requirements of an enterprise. The multi-cloud IT environment incorporates different clouds from multiple vendors and negates the dependence on a single public cloud service provider. Thus enterprises can choose specific services from multiple public clouds and reap the benefits of each.

Given its affordability and agility, most enterprises opt for a multi-cloud approach in cloud computing now. A 2018 survey on the public cloud services market points out that 81% of the respondents use services from two or more providers. Subsequently, the cloud computing services market has reported incredible growth in recent times. The worldwide public cloud services market is all set to reach $500 billion in the next four years, according to IDC.

By choosing multi-cloud solutions strategically, enterprises can optimize the benefits of cloud computing and aim for some key competitive advantages. They can avoid the lengthy and cumbersome processes involved in buying, installing and testing high-priced systems. The IaaS and PaaS solutions have become a windfall for the enterprise’s budget as it does not incur huge up-front capital expenditure.

However, cost optimization is still a challenge while facilitating a multi-cloud environment and a large number of enterprises end up overpaying with or without realizing it. The below-mentioned tips would help you ensure the money is spent wisely on cloud computing services.

  • Deactivate underused or unattached resources

Most organizations tend to get wrong with simple things which turn out to be the root cause for needless spending and resource wastage. The first step to cost optimization in your cloud strategy is to identify underutilized resources that you have been paying for.

Enterprises often continue to pay for resources that have been purchased earlier but are no longer useful. Identifying such unused and unattached resources and deactivating it on a regular basis brings you one step closer to cost optimization. If needed, you can deploy automated cloud management tools that are largely helpful in providing the analytics needed to optimize the cloud spending and cut costs on an ongoing basis.

  • Figure out idle instances

Another key cost optimization strategy is to identify the idle computing instances and consolidate them into fewer instances. An idle computing instance may require a CPU utilization level of 1-5%, but you may be billed by the service provider for 100% for the same instance.

Every enterprise will have such non-production instances that constitute unnecessary storage space and lead to overpaying. Re-evaluating your resource allocations regularly and removing unnecessary storage may help you save money significantly. Resource allocation is not only a matter of CPU and memory but also it is linked to the storage, network, and various other factors.

  • Deploy monitoring mechanisms

The key to efficient cost reduction in cloud computing technology lies in proactive monitoring. A comprehensive view of the cloud usage helps enterprises to monitor and minimize unnecessary spending. You can make use of various mechanisms for monitoring computing demand.

For instance, you can use a heatmap to understand the highs and lows in computing visually. This heat map indicates the start and stop times which in turn lead to reduced costs. You can also deploy automated tools that help organizations to schedule instances to start and stop. By following a heatmap, you can understand whether it is safe to shut down servers on holidays or weekends.

#cloud computing services #all #hybrid cloud #cloud #multi-cloud strategy #cloud spend #multi-cloud spending #multi cloud adoption #why multi cloud #multi cloud trends #multi cloud companies #multi cloud research #multi cloud market

OpenTelemetry、Spring Cloud Sleuth、Kafka、およびJaegerを使用した分散トレース

分散トレースは、特定のサービスが分散ソフトウェアシステム全体の一部としてどのように実行されているかについての洞察を提供します。発信元から宛先、および通過するシステムまでのリクエストを追跡および記録します。

この記事では、OpenTelemetry、Spring Cloud Sleuth、Kafka、およびJaegerを使用して、3つのSpringBootマイクロサービスに分散トレースを実装します。

まず、分散トレースの基本的な用語のいくつかを見てみましょう。

スパン:システム内の単一の作業単位を表します。スパンを相互にネストして、作業の分解をモデル化できます。たとえば、あるスパンがRESTエンドポイントを呼び出し、別の子スパンがそのエンドポイントが別のエンドポイントを呼び出すようにし、以下同様に別のサービスで行うことができます。

トレース:すべてが同じルートスパンを共有するスパンのコレクション、またはより単純に、元のリクエストの直接の結果として作成されたすべてのスパンを配置します。スパンの階層(それぞれがルートスパンに沿って独自の親スパンを持つ)を使用して、さまざまなコンポーネントを通過する際のリクエストのパスを示す有向非巡回グラフを作成できます。

OpenTelemetry

OpenTelemetryは、略してOTelとも呼ばれ、トレースメトリックログなどのテレメトリデータを計測、生成、収集、およびエクスポートするための、ベンダーに依存しないオープンソースの可観測性フレームワークです。Cloud Native Computing Foundation(CNCF)のインキュベーションプロジェクトとして、OTelは、主にデータを収集してどこかに転送するために、ベンダーに依存しないライブラリとAPIの統合セットを提供することを目指しています。OTelは、テレメトリデータを生成および管理するための世界標準になりつつあり、広く採用されています。

Spring Cloud Sleuth

Sleuthは、SpringBootアプリケーション内に分散トレース機能を統合することを目的としたSpringCloudチームによって管理および保守されているプロジェクトです。これは一般的なものとしてバンドルされているSpring Starterため、依存関係として追加するだけで、自動構成がアプリ全体のすべての統合とインストルメンテーションを処理します。すぐに使用できるSleuthインストゥルメントは次のとおりです。

  • Spring MVCコントローラー(RESTエンドポイント)で受信したリクエスト
  • KafkaやMQなどのメッセージングテクノロジーを介したリクエスト
  • RestTemplateWebClientなどで行われたリクエスト

Sleuthはインターセプターを追加して、すべてのトレース情報がリクエストで確実に渡されるようにします。呼び出しが行われるたびに、新しいスパンが作成されます。応答を受信すると閉じられます。

Sleuthはリクエストとメッセージを追跡できるため、その通信を対応するログエントリに関連付けることができます。トレース情報を外部システムにエクスポートして、遅延を視覚化することもできます。

イエーガー

Jaegerは元々Uberのチームによって構築され、2015年にオープンソースになりました。2017年にクラウドネイティブインキュベーションプロジェクトとして受け入れられ、2019年に卒業しました。CNCFの一部として、Jaegerはクラウドネイティブアーキテクチャで認められたプロジェクトです。そのソースコードは主にGoで書かれています。イエーガーのアーキテクチャには次のものが含まれます。

  • インストルメンテーションライブラリ
  • コレクター
  • クエリサービスとWebUI
  • データベースストレージ

Jaegerと同様に、Zipkinもそのアーキテクチャで同じコンポーネントのセットを提供します。Zipkinは古いプロジェクトですが、Jaegerはよりモダンでスケーラブルなデザインになっています。この例では、バックエンドとしてJaegerを選択しました。

トレースシステムの設計

3つのSpringBootマイクロサービスを設計しましょう。

  • customer-service-bffbackend for frontendパターンを使用して、このサービスはUIとバックエンドの間に配置されます。これはUIWebアプリによって呼び出され、UIWebアプリはRESTAPI呼び出しを介してバックエンドカスタマーサービスを呼び出します。
  • customer-service:シンプルなカスタマーCRUDサービス。CRUD操作時にデータベースにデータを保持するだけでなく、顧客レコードを作成、更新、または削除するときにイベントをKafkaに公開します。
  • order-service:Kafkaトピックをリッスンし、顧客が作成/更新/削除したイベントを消費します。

3つのマイクロサービスは次のように設計されています。

  • REST APIを介して通信する(customer-service-bffおよびcustomer-service
  • customer-serviceKafka(およびorder-service)を介したイベント駆動型のpub/subを介した通信

これは、OpenTelemetryとSpring Cloud Sleuthを組み合わせて、コードの自動インストルメンテーションを処理し、トレースデータを生成して送信する方法を観察するためのものです。上記の点線は、マイクロサービスによってエクスポートされたトレースデータのパスをキャプチャし、OTLP(OpenTelemetry Line Protocol)を介してOpenTelemetry Collectorに移動し、コレクターはトレースデータを処理してバックエンドJaegerにエクスポートし、保存してクエリを実行します。

モノレポを使用すると、次のようなプロジェクト構造になります。

ステップ1:POMの依存関係を追加する

これは、OTelとSpringCloudSleuthを使用して分散トレースを実装するための鍵です。私たちの目標は、コードを手動でインストルメントする必要がないため、これらの依存関係に依存して、設計されていることを実行します。実装のトレースに加えて、コードの自動インストルメンテーション、テレメトリデータのOTelコレクターへのエクスポートなどです。


<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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-otel-dependencies</artifactId>
            <version>${spring-cloud-sleuth-otel.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-sleuth-brave</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-otel-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-exporter-otlp-trace</artifactId>
    </dependency>
</dependencies>
  • spring-cloud-dependencies:SpringCloudの依存関係
  • spring-cloud-sleuth-otel-dependencies:Spring CloudSleuthOpenTelemetryの依存関係
  • spring-cloud-starter-sleuth:Sleuthは、モジュールで使用可能なブリッジを介してOpenZipkinBraveトレーサーと統合されspring-cloud-sleuth-braveます。バックエンドにZipkinを使用していないため、依存関係から除外spring-cloud-sleuth-braveし、spring-cloud-starter-sleuth代わりに依存関係を追加する必要がありspring-cloud-sleuth-otel-autoconfigureます。これにより、 Braveに基づくデフォルトのトレース実装がOpenTelemetryに基づく実装に置き換えられます。
  • opentelemetry-exporter-otlp-trace:これは、OpenTelemetryCollectorにトレースを送信するSpringCloudSleuthOTelのコンポーネントです。

ステップ2:OpenTelemetryの構成

OpenTelemetryCollectorエンドポイント

マイクロサービスごとに、次の構成をに追加する必要がありますapplication.yml(以下のセクションのサンプルスニペットを参照)。spring.sleuth.otel.exporter.otlp.endpoint主にOTelCollectorエンドポイントを構成するためのものです。これは、エクスポーター(この場合はSleuth)に、OTLPを介して指定されたコレクターエンドポイントにトレースデータを送信するように指示しますhttp://otel-collector:4317。エンドポイントURLの通知otel-collectorは、画像のdocker-composeサービスからのotel-collectorものです。

データ確率サンプリングのトレース

spring.sleuth.otel.config.trace-id-ratio-basedプロパティは、トレースデータのサンプリング確率を定義します。サンプラーに与えられたフラクションに基づいて、トレースのフラクションをサンプリングします。確率サンプリングにより、OpenTelemetryトレースのユーザーは、ランダム化されたサンプリング手法を使用してスパン収集コストを削減できます。比率が1.0未満の場合、一部のトレースはエクスポートされません。この例では、サンプリングを1.0、100%に構成します。

その他のOTelSpringCloud Sleuthプロパティについては、一般的なアプリケーションプロパティを参照してください。

spring:
  application:
    name: customer-service
  sleuth:
    otel:
      config:
        trace-id-ratio-based: 1.0
      exporter:
        otlp:
          endpoint: http://otel-collector:4317

OpenTelemetry構成ファイル

otel-config.yamlプロジェクトルートにOTel構成ファイルが必要です。内容は以下の通りです。この構成ファイルは、OTelレシーバー、プロセッサー、およびエクスポーターの動作を定義します。ご覧のとおり、gRPCとHTTPでリッスンするようにレシーバーを定義し、バッチとエクスポーターをイェーガーとロギングとして使用するプロセッサーを定義しました。

extensions:
  memory_ballast:
    size_mib: 512
  zpages:
    endpoint: 0.0.0.0:55679

receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:

exporters:
  logging:
    logLevel: debug
  jaeger:
    endpoint: jaeger-all-in-one:14250
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [ otlp ]
      processors: [ batch ]
      exporters: [ logging, jaeger ]
  extensions: [ memory_ballast, zpages ]

ステップ3:docker-すべて一緒に文字列を作成する

これらの3つのマイクロサービスを実行して分散トレースを観察するためにスピンアップする必要のあるDockerコンテナーを見てみましょう。最初の3つのマイクロサービスについては、上記のセクションで説明しています。

  • customer-service-bff
  • customer-service
  • order-service
  • postgres-customer:データベースcustomer-service
  • postgres-order:データベースorder-service
  • jaeger-all-in-one:すべてのJaegerバックエンドコンポーネントとUIを実行する単一のイメージ
  • otel-collector:OpenTelemetryトレースのエンジンであり、トレースデータを受信、処理、およびバックエンドにエクスポートします
  • zookeeper:Kafkaクラスター内のノードのステータスを追跡し、Kafkaトピックとメッセージのリストを維持します
  • kafka:pub/subイベントストリーミング処理プラットフォーム
services:

  customer-service-bff:
    image: customer-service-bff:0.0.1-SNAPSHOT
    ports:
      - "8080:8080"
    depends_on:
      - zookeeper
      - kafka

  customer-service:
    image: customer-service:0.0.1-SNAPSHOT
    ports:
      - "8081:8081"
    depends_on:
      - zookeeper
      - kafka
      - postgres-customer
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-customer:5432/customerservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  order-service:
    image: order-service:0.0.1-SNAPSHOT
    ports:
      - "8082:8082"
    depends_on:
      - zookeeper
      - kafka
      - postgres-order
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-order:5432/orderservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  postgres-customer:
    image: postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=customerservice

  postgres-order:
    image: postgres
    ports:
      - "5431:5431"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=orderservice

  jaeger-all-in-one:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"
      - "14268"
      - "14250"

  otel-collector:
    image: otel/opentelemetry-collector:0.47.0
    command: [ "--config=/etc/otel-collector-config.yaml" ]
    volumes:
      - ./otel-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "1888:1888"   # pprof extension
      - "13133:13133" # health_check extension
      - "4317"        # OTLP gRPC receiver
      - "55670:55679" # zpages extension
    depends_on:
      - jaeger-all-in-one

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

docker-compose up -d9つのコンテナすべてを起動するために実行します。

ステップ4:実際のデータのトレース

ハッピーパス

customer-service-bffそれでは、フローへのエントリポイントであるを起動して、新しい顧客を作成しましょう。

Jaeger UIを起動し、サービスhttp://localhost:16686/検索し、ボタンcustomer-service-bffをクリックしFind Tracesます。これが、顧客トレースの作成で表示されるものです。これは、3つのサービスにまたがり、合計で6にまたがり、期間は82.35ミリ秒です。

トレースタイムラインビュー(上のスクリーンショット)に加えて、イエーガーはグラフビュー(Trace Graph右上のドロップダウンで選択)も提供します。

3つのマイクロサービスのDockerのログ出力には、同じトレースIDが赤で強調表示され、アプリ名に応じてスパンIDが異なります(アプリケーション名と対応するスパンIDは一致する色で強調表示されます)。の場合customer-service、同じスパンIDがRESTAPIリクエストからKafkaパブリッシャーリクエストに渡されます。

エラーシナリオ

customer-serviceDockerでPostgreSQLデータベースを一時停止し、から顧客の作成フローを繰り返しますcustomer-service-bff500 internal server errorさすがに手に入れた。Jaegerをチェックインすると、次のトレースが表示されますが、例外のstacktraceがSocketTimeoutException、再び予想どおりに文句を言っています。

長期的なスパンの特定

Jaeger UIを使用すると、指定した最大期間よりも長いトレースを検索できます。たとえば、1000ミリ秒より長くかかったすべてのトレースを検索できます。次に、長時間実行されているトレースにドリルダウンして、それらの根本原因を調査できます。

概要

このストーリーでは、OpenTelemetry、Spring Cloud Sleuth、およびJaegerのレンズで分散トレースを解凍し、RESTAPI呼び出しとKafkapub/subの両方で分散トレースの自動インストルメンテーションを検証しました。このストーリーが、これらのトレースフレームワークとツール、特にOpenTelemetryについての理解を深め、分散システムでの可観測性の方法を根本的に変える方法を理解してくれることを願っています。

このストーリーのソースコードは、私のGitHubリポジトリにあります。

ハッピーコーディング!

このストーリーは、もともとhttps://betterprogramming.pub/distributed-tracing-with-opentelemetry-spring-cloud-sleuth-kafka-and-jaeger-939e35f45821で公開されました

#jaeger #opentelemetry #spring #cloud #kafka 

Distributed Tracing With OpenTelemetry, Spring Cloud Sleuth, Kafka, and Jaeger

Distributed tracing gives you insight into how a particular service is performing as part of the whole in a distributed software system. It tracks and records requests from their point of origin to their destination and the systems through which they pass.

In this article, we are going to implement distributed tracing in three Spring Boot microservices using OpenTelemetry, Spring Cloud Sleuth, Kafka, and Jaeger.

Let’s first take a look at some of the basic terms in distributed tracing.

Span: Represents a single unit of work within the system. Spans can be nested within one another to model the decomposition of the work. For example, a span could be calling a REST endpoint and another child span could then be that endpoint calling another, and so on in a different service.

Trace: A collection of spans that all share the same root span, or more simply put all spans which were created as a direct result of the original request. The hierarchy of spans (each with its own parent span alongside the root span) can be used to form directed acyclic graphs showing the path of the request as it made its way through various components.

OpenTelemetry

OpenTelemetry, also known as OTel for short, is a vendor-neutral open source Observability framework for instrumenting, generating, collecting, and exporting telemetry data such as traces, metrics, and logs. As a Cloud Native Computing Foundation (CNCF) incubating project, OTel aims to provide unified sets of vendor-agnostic libraries and APIs — mainly for collecting data and transferring it somewhere. OTel is becoming the world standard for generating and managing telemetry data, and it is being widely adopted.

Spring Cloud Sleuth

Sleuth is a project managed and maintained by the Spring Cloud team aimed at integrating distributed tracing functionality within Spring Boot applications. It is bundled as a typical Spring Starter, so by just adding it as a dependency the auto-configuration handles all the integration and instrumenting across the app. Here’s some out-of-the-box Sleuth instruments:

  • requests received at Spring MVC controllers (REST endpoints)
  • requests over messaging technologies like Kafka or MQ
  • requests made with RestTemplate, WebClient, etc.

Sleuth adds an interceptor to ensure that all the tracing information is passed in the requests. Each time a call is made, a new Span is created. It gets closed upon receiving the response.

Sleuth is able to trace your requests and messages so that you can correlate that communication to corresponding log entries. You can also export the tracing information to an external system to visualize latency.

Jaeger

Jaeger was originally built by teams at Uber and then open sourced in 2015. It got accepted as a Cloud Native incubation project in 2017 and graduated in 2019. As part of CNCF, Jaeger is a recognized project in cloud-native architectures. Its source code is primarily written in Go. The architecture of Jaeger includes:

  • Instrumentation Libraries
  • Collectors
  • Query Service and web UI
  • Database Storage

Similar to Jaeger, Zipkin also provides the same set of components in its architecture. Though Zipkin is an older project, Jaeger has a more modern and scalable design. For this example, we have chosen Jaeger as the backend.

Tracing System Design

Let’s design three Spring Boot microservices:

  • customer-service-bff: using backend for frontend pattern, this service sits between the UI and the backend. It is called by a UI web app, which in turn, calls the back end customer service via REST API calls.
  • customer-service: a simple customer CRUD service. In addition to persisting data to its database upon CRUD operations, it also publishes events to Kafka when creating, updating, or deleting a customer record.
  • order-service: listens on the Kafka topic, consumes customer-created/updated/deleted events.

The three microservices are designed to:

  • communicate via REST API (customer-service-bff and customer-service)
  • communicate via event-driven pub/sub through Kafka (customer-service and order-service)

This is to observe how OpenTelemetry combined with Spring Cloud Sleuth handles auto instrumentation of the code and generates and transmits the tracing data. The dotted lines above capture the path of the tracing data, exported by the microservices, travels to OpenTelemetry Collector via OTLP (OpenTelemetry Line Protocol), and the Collector in turn processes and exports the tracing data to the backend Jaeger to be stored and queried.

Using a monorepo, we have the project structure as follows:

Step 1: Add POM Dependencies

This is the key to implementing distributed tracing using OTel and Spring Cloud Sleuth. Our goal is not to have to manually instrument our code, so we rely on these dependencies to do what they are designed to do — auto instrumenting our code, in addition to tracing implementation, exporting telemetry data to the OTel Collector, etc.


<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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-otel-dependencies</artifactId>
            <version>${spring-cloud-sleuth-otel.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-sleuth-brave</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-otel-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-exporter-otlp-trace</artifactId>
    </dependency>
</dependencies>
  • spring-cloud-dependencies: Spring Cloud dependencies
  • spring-cloud-sleuth-otel-dependencies: Spring Cloud Sleuth OpenTelemetry dependencies
  • spring-cloud-starter-sleuth: Sleuth integrates with the OpenZipkin Brave tracer via the bridge that is available in the spring-cloud-sleuth-brave module. Since we are not using Zipkin for back end, we have to exclude spring-cloud-sleuth-brave from the spring-cloud-starter-sleuth dependency and instead add in the spring-cloud-sleuth-otel-autoconfigure dependency. This replaces the default tracing implementation based on Brave with the implementation based on OpenTelemetry.
  • opentelemetry-exporter-otlp-trace: this is the component in Spring Cloud Sleuth OTel that sends traces to an OpenTelemetry Collector.

Step 2: OpenTelemetry Configuration

OpenTelemetry Collector endpoint

For each microservice, we need to add the following configuration in application.yml(see sample snippet in the section below). spring.sleuth.otel.exporter.otlp.endpoint is mainly to configure the OTel Collector endpoint. It tells the exporter, Sleuth in our case, to send the tracing data via OTLP to the specified collector endpoint http://otel-collector:4317. Notice otel-collector in the endpoint URL comes from the docker-compose service for otel-collector image.

Tracing Data Probability Sampling

spring.sleuth.otel.config.trace-id-ratio-based property defines the tracing data sampling probability. It samples a fraction of traces based on the fraction given to the sampler. Probability sampling allows OpenTelemetry tracing users to lower span collection costs by the use of randomized sampling techniques. If the ratio is less than 1.0, some traces will not be exported. For this example, we will configure the sampling to be 1.0, 100%.

For additional OTel Spring Cloud Sleuth properties, see common application properties.

spring:
  application:
    name: customer-service
  sleuth:
    otel:
      config:
        trace-id-ratio-based: 1.0
      exporter:
        otlp:
          endpoint: http://otel-collector:4317

OpenTelemetry Configuration File

We need an OTel configuration file otel-config.yaml at the project root. The content is as follows. This configuration file defines the behaviors of the OTel receivers, processors, and exporters. As we can see, we defined our receivers to listen on gRPC and HTTP, processors using batch and exporters as jaeger and logging.

extensions:
  memory_ballast:
    size_mib: 512
  zpages:
    endpoint: 0.0.0.0:55679

receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:

exporters:
  logging:
    logLevel: debug
  jaeger:
    endpoint: jaeger-all-in-one:14250
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [ otlp ]
      processors: [ batch ]
      exporters: [ logging, jaeger ]
  extensions: [ memory_ballast, zpages ]

Step 3: docker-compose to string all together

Let’s look at the docker containers we need to spin up in order to run these three microservices and observe their distributed tracing, the first three microservices are explained in the section above.

  • customer-service-bff
  • customer-service
  • order-service
  • postgres-customer: database for customer-service
  • postgres-order: database for order-service
  • jaeger-all-in-one: single image that runs all Jaeger backend components and UI
  • otel-collector: the engine of OpenTelemetry tracing, it receives, processes, and exports the tracing data to the backend
  • zookeeper: track the status of nodes in the Kafka cluster and maintain a list of Kafka topics and messages
  • kafka: pub/sub event streaming processing platform
services:

  customer-service-bff:
    image: customer-service-bff:0.0.1-SNAPSHOT
    ports:
      - "8080:8080"
    depends_on:
      - zookeeper
      - kafka

  customer-service:
    image: customer-service:0.0.1-SNAPSHOT
    ports:
      - "8081:8081"
    depends_on:
      - zookeeper
      - kafka
      - postgres-customer
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-customer:5432/customerservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  order-service:
    image: order-service:0.0.1-SNAPSHOT
    ports:
      - "8082:8082"
    depends_on:
      - zookeeper
      - kafka
      - postgres-order
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-order:5432/orderservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  postgres-customer:
    image: postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=customerservice

  postgres-order:
    image: postgres
    ports:
      - "5431:5431"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=orderservice

  jaeger-all-in-one:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"
      - "14268"
      - "14250"

  otel-collector:
    image: otel/opentelemetry-collector:0.47.0
    command: [ "--config=/etc/otel-collector-config.yaml" ]
    volumes:
      - ./otel-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "1888:1888"   # pprof extension
      - "13133:13133" # health_check extension
      - "4317"        # OTLP gRPC receiver
      - "55670:55679" # zpages extension
    depends_on:
      - jaeger-all-in-one

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

Run docker-compose up -d to bring up all nine containers:

Step 4: Tracing Data in Action

Happy path

Now, let’s launch our customer-service-bff, the entry point to the flow, to create a new customer.

Launch Jaeger UI, http://localhost:16686/, search by service customer-service-bff, click on Find Traces button, here is what we see for the create customer trace: it spanned three services, total spans six, duration 82.35ms.

In addition to the Trace Timeline view (screenshot above), Jaeger also provides a graph view (select Trace Graph in the top-right dropdown):

The log output in docker for three microservices shows the same trace id, highlighted in red, and differing span id according to their app name (application names and their corresponding span ids are highlighted in matching colors). In the case of customer-service, the same span id is passed from the REST API request to the Kafka publisher request.

Error scenario

Let’s pause our customer-service PostgreSQL database in docker, and repeat the create customer flow from customer-service-bff. We got 500 internal server error, as expected. Checking in Jaeger, we see the following trace, with the exception stacktrace complaining about SocketTimeoutException, again as expected.

Identifying long-running spans

Jaeger UI allows us to search for traces that are longer than a specified max duration. For example, we can search for all traces that have taken longer than 1000ms. We can then drill down into the long-running traces to investigate their root causes.

Summary

We unpacked distributed tracing in the lens of OpenTelemetry, Spring Cloud Sleuth, and Jaeger in this story, verifying the auto instrumentation of distributed tracing in both REST API calls and Kafka pub/sub. I hope this story gives you a better understanding of these tracing frameworks and tooling, especially OpenTelemetry, and how it fundamentally changes how we do Observability in distributed systems.

The source code for this story can be found in my GitHub repo.

Happy coding!

This story was originally published at https://betterprogramming.pub/distributed-tracing-with-opentelemetry-spring-cloud-sleuth-kafka-and-jaeger-939e35f45821

#jaeger #opentelemetry #spring #cloud #kafka 

Seguimiento Distribuido Con OpenTelemetry, Spring Cloud Sleuth, Kafka

El seguimiento distribuido le brinda información sobre el rendimiento de un servicio en particular como parte del todo en un sistema de software distribuido. Realiza un seguimiento y registra las solicitudes desde su punto de origen hasta su destino y los sistemas por los que pasan.

En este artículo, implementaremos el rastreo distribuido en tres microservicios Spring Boot usando OpenTelemetry, Spring Cloud Sleuth, Kafka y Jaeger.

Primero echemos un vistazo a algunos de los términos básicos en el rastreo distribuido.

Span: Representa una sola unidad de trabajo dentro del sistema. Los tramos se pueden anidar unos dentro de otros para modelar la descomposición del trabajo. Por ejemplo, un tramo podría estar llamando a un extremo REST y otro tramo secundario podría ser ese extremo llamando a otro, y así sucesivamente en un servicio diferente.

Seguimiento: una colección de tramos que comparten el mismo tramo raíz o, más simplemente, poner todos los tramos que se crearon como resultado directo de la solicitud original. La jerarquía de tramos (cada uno con su propio tramo principal junto con el tramo raíz) se puede utilizar para formar gráficos acíclicos dirigidos que muestren la ruta de la solicitud a medida que avanza a través de varios componentes.

OpenTelemetry

OpenTelemetry , también conocido como OTel para abreviar, es un marco de observabilidad de código abierto independiente del proveedor para instrumentar, generar, recopilar y exportar datos de telemetría, como seguimientos , métricas y registros . Como proyecto de incubación de Cloud Native Computing Foundation (CNCF), OTel tiene como objetivo proporcionar conjuntos unificados de bibliotecas y API independientes del proveedor, principalmente para recopilar datos y transferirlos a algún lugar. OTel se está convirtiendo en el estándar mundial para generar y administrar datos de telemetría, y se está adoptando ampliamente.

Detective de nubes de primavera

Sleuth es un proyecto administrado y mantenido por el equipo de Spring Cloud destinado a integrar la funcionalidad de rastreo distribuido dentro de las aplicaciones Spring Boot. Se incluye como un paquete típico Spring Starter, por lo que con solo agregarlo como una dependencia, la configuración automática maneja toda la integración y la instrumentación en toda la aplicación. Aquí hay algunos instrumentos de Sleuth listos para usar:

  • solicitudes recibidas en los controladores Spring MVC (puntos finales REST)
  • solicitudes sobre tecnologías de mensajería como Kafka o MQ
  • solicitudes realizadas con RestTemplate, WebClient, etc.

Sleuth agrega un interceptor para garantizar que toda la información de rastreo se transmita en las solicitudes. Cada vez que se realiza una llamada, se crea un nuevo Span. Se cierra al recibir la respuesta.

Sleuth puede rastrear sus solicitudes y mensajes para que pueda correlacionar esa comunicación con las entradas de registro correspondientes. También puede exportar la información de seguimiento a un sistema externo para visualizar la latencia.

Jaeger

Jaeger fue creado originalmente por equipos de Uber y luego fue abierto en 2015. Fue aceptado como un proyecto de incubación nativo de la nube en 2017 y se graduó en 2019. Como parte de CNCF, Jaeger es un proyecto reconocido en arquitecturas nativas de la nube. Su código fuente está escrito principalmente en Go. La arquitectura de Jaeger incluye:

  • Bibliotecas de instrumentación
  • Coleccionistas
  • Servicio de consultas e interfaz de usuario web
  • Almacenamiento de base de datos

Similar a Jaeger, Zipkin también proporciona el mismo conjunto de componentes en su arquitectura. Aunque Zipkin es un proyecto más antiguo, Jaeger tiene un diseño más moderno y escalable. Para este ejemplo, hemos elegido a Jaeger como backend.

Diseño del sistema de rastreo

Diseñemos tres microservicios Spring Boot:

  • customer-service-bff: usando backend for frontendun patrón, este servicio se encuentra entre la interfaz de usuario y el backend. Lo llama una aplicación web de interfaz de usuario, que a su vez llama al servicio de atención al cliente de back-end a través de llamadas API REST.
  • customer-service: un simple servicio CRUD al cliente. Además de conservar los datos en su base de datos sobre las operaciones CRUD, también publica eventos en Kafka al crear, actualizar o eliminar un registro de cliente.
  • order-service: escucha el tema de Kafka, consume eventos creados/actualizados/eliminados por el cliente.

Los tres microservicios están diseñados para:

  • comunicarse a través de la API REST ( customer-service-bffy customer-service)
  • comunicarse a través de pub/sub basado en eventos a través de Kafka ( customer-servicey order-service)

Esto es para observar cómo OpenTelemetry combinado con Spring Cloud Sleuth maneja la instrumentación automática del código y genera y transmite los datos de seguimiento. Las líneas punteadas de arriba capturan la ruta de los datos de rastreo, exportados por los microservicios, viajan a OpenTelemetry Collector a través de OTLP (OpenTelemetry Line Protocol) y, a su vez, Collector procesa y exporta los datos de rastreo al backend Jaeger para almacenarlos y consultarlos.

Usando un monorepo, tenemos la estructura del proyecto de la siguiente manera:

Paso 1: agregar dependencias de POM

Esta es la clave para implementar el rastreo distribuido utilizando OTel y Spring Cloud Sleuth. Nuestro objetivo es no tener que instrumentar manualmente nuestro código, por lo que confiamos en estas dependencias para hacer aquello para lo que están diseñadas: instrumentar automáticamente nuestro código, además de rastrear la implementación, exportar datos de telemetría a OTel Collector, etc.


<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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-otel-dependencies</artifactId>
            <version>${spring-cloud-sleuth-otel.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-sleuth-brave</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-otel-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-exporter-otlp-trace</artifactId>
    </dependency>
</dependencies>
  • spring-cloud-dependencies: Dependencias de Spring Cloud
  • spring-cloud-sleuth-otel-dependencies: Spring Cloud Sleuth Dependencias de OpenTelemetry
  • spring-cloud-starter-sleuth: Sleuth se integra con el rastreador OpenZipkin Brave a través del puente que está disponible en el spring-cloud-sleuth-bravemódulo. Como no estamos usando Zipkin para el back-end, tenemos que excluir spring-cloud-sleuth-bravede la spring-cloud-starter-sleuthdependencia y, en su lugar, agregar la spring-cloud-sleuth-otel-autoconfiguredependencia. Esto reemplaza la implementación de seguimiento predeterminada basada en Brave con la implementación basada en OpenTelemetry.
  • opentelemetry-exporter-otlp-trace: este es el componente en Spring Cloud Sleuth OTel que envía rastros a un OpenTelemetry Collector.

Paso 2: Configuración de OpenTelemetry

Extremo de OpenTelemetry Collector

Para cada microservicio, debemos agregar la siguiente configuración application.yml(consulte el fragmento de código de muestra en la sección a continuación). spring.sleuth.otel.exporter.otlp.endpointes principalmente para configurar el punto final de OTel Collector. Le dice al exportador, Sleuth en nuestro caso, que envíe los datos de seguimiento a través de OTLP al punto final del recopilador especificado http://otel-collector:4317. El aviso otel-collectoren la URL del punto final proviene del servicio docker-compose para la otel-collectorimagen.

Muestreo probabilístico de datos de rastreo

spring.sleuth.otel.config.trace-id-ratio-basedLa propiedad define la probabilidad de muestreo de los datos de rastreo. Muestrea una fracción de trazas en función de la fracción entregada al muestreador. El muestreo de probabilidad permite a los usuarios de seguimiento de OpenTelemetry reducir los costos de recopilación de tramos mediante el uso de técnicas de muestreo aleatorio. Si la proporción es inferior a 1,0, algunos rastros no se exportarán. Para este ejemplo, configuraremos el muestreo para que sea 1.0, 100%.

Para conocer las propiedades adicionales de OTel Spring Cloud Sleuth, consulte las propiedades comunes de la aplicación .

spring:
  application:
    name: customer-service
  sleuth:
    otel:
      config:
        trace-id-ratio-based: 1.0
      exporter:
        otlp:
          endpoint: http://otel-collector:4317

Archivo de configuración de OpenTelemetry

Necesitamos un archivo de configuración de OTel otel-config.yamlen la raíz del proyecto. El contenido es el siguiente. Este archivo de configuración define los comportamientos de los receptores, procesadores y exportadores de OTel. Como podemos ver, definimos nuestros receptores para escuchar en gRPC y HTTP, procesadores que usan lote y exportadores como jaeger y registro.

extensions:
  memory_ballast:
    size_mib: 512
  zpages:
    endpoint: 0.0.0.0:55679

receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:

exporters:
  logging:
    logLevel: debug
  jaeger:
    endpoint: jaeger-all-in-one:14250
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [ otlp ]
      processors: [ batch ]
      exporters: [ logging, jaeger ]
  extensions: [ memory_ballast, zpages ]

Paso 3: docker-compose para unir todo

Veamos los contenedores docker que necesitamos activar para ejecutar estos tres microservicios y observemos su seguimiento distribuido, los primeros tres microservicios se explican en la sección anterior.

  • customer-service-bff
  • customer-service
  • order-service
  • postgres-customer: base de datos paracustomer-service
  • postgres-order: base de datos paraorder-service
  • jaeger-all-in-one: imagen única que ejecuta todos los componentes back-end y la interfaz de usuario de Jaeger
  • otel-collector: el motor de seguimiento de OpenTelemetry, recibe, procesa y exporta los datos de seguimiento al backend
  • zookeeper: realice un seguimiento del estado de los nodos en el clúster de Kafka y mantenga una lista de temas y mensajes de Kafka
  • kafka: plataforma de procesamiento de transmisión de eventos pub/sub
services:

  customer-service-bff:
    image: customer-service-bff:0.0.1-SNAPSHOT
    ports:
      - "8080:8080"
    depends_on:
      - zookeeper
      - kafka

  customer-service:
    image: customer-service:0.0.1-SNAPSHOT
    ports:
      - "8081:8081"
    depends_on:
      - zookeeper
      - kafka
      - postgres-customer
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-customer:5432/customerservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  order-service:
    image: order-service:0.0.1-SNAPSHOT
    ports:
      - "8082:8082"
    depends_on:
      - zookeeper
      - kafka
      - postgres-order
    environment:
      - SPRING_DATASOURCE_JDBC-URL=jdbc:postgresql://postgres-order:5432/orderservice
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
      - SPRING_JPA_HIBERNATE_DDL_AUTO=update

  postgres-customer:
    image: postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=customerservice

  postgres-order:
    image: postgres
    ports:
      - "5431:5431"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=orderservice

  jaeger-all-in-one:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"
      - "14268"
      - "14250"

  otel-collector:
    image: otel/opentelemetry-collector:0.47.0
    command: [ "--config=/etc/otel-collector-config.yaml" ]
    volumes:
      - ./otel-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "1888:1888"   # pprof extension
      - "13133:13133" # health_check extension
      - "4317"        # OTLP gRPC receiver
      - "55670:55679" # zpages extension
    depends_on:
      - jaeger-all-in-one

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

Corre docker-compose up -dpara que aparezcan los nueve contenedores:

Paso 4: Seguimiento de datos en acción

camino feliz

Ahora, lancemos nuestro customer-service-bff, el punto de entrada al flujo, para crear un nuevo cliente.

Inicie la interfaz de usuario de Jaeger http://localhost:16686/, busque por servicio customer-service-bff, haga clic en el Find Tracesbotón, esto es lo que vemos para crear el seguimiento del cliente: abarcó tres servicios, un total de seis, una duración de 82,35 ms.

Además de la vista de línea de tiempo de seguimiento (captura de pantalla anterior), Jaeger también proporciona una vista de gráfico (seleccione Trace Graphen el menú desplegable superior derecho):

El resultado del registro en la ventana acoplable para tres microservicios muestra el mismo ID de seguimiento, resaltado en rojo, y un ID de tramo diferente según el nombre de la aplicación (los nombres de las aplicaciones y sus ID de tramo correspondientes se resaltan en colores coincidentes). En el caso de customer-service, se pasa el mismo ID de intervalo desde la solicitud de la API de REST a la solicitud del editor de Kafka.

Escenario de error

Hagamos una pausa en nuestra customer-servicebase de datos PostgreSQL en la ventana acoplable y repitamos el flujo de creación de clientes desde customer-service-bff. Lo conseguimos 500 internal server error, como era de esperar. Al verificar en Jaeger, vemos el siguiente seguimiento, con la excepción de stacktrace quejándose SocketTimeoutException, nuevamente como se esperaba.

Identificación de tramos de larga duración

La interfaz de usuario de Jaeger nos permite buscar rastros que superen la duración máxima especificada. Por ejemplo, podemos buscar todas las trazas que hayan tardado más de 1000 ms. Luego, podemos profundizar en los rastros de ejecución prolongada para investigar sus causas principales.

Resumen

Desempaquetamos el rastreo distribuido en la lente de OpenTelemetry, Spring Cloud Sleuth y Jaeger en esta historia, verificando la instrumentación automática del rastreo distribuido en las llamadas API REST y Kafka pub/sub. Espero que esta historia le brinde una mejor comprensión de estos marcos y herramientas de seguimiento, especialmente OpenTelemetry, y cómo cambia fundamentalmente la forma en que hacemos la Observabilidad en los sistemas distribuidos.

El código fuente de esta historia se puede encontrar en mi repositorio de GitHub .

¡Feliz codificación!

Esta historia se publicó originalmente en https://betterprogramming.pub/distributed-tracing-with-opentelemetry-spring-cloud-sleuth-kafka-and-jaeger-939e35f45821

#jaeger #opentelemetry #spring #cloud #kafka