GridDB Developer
EN
ダウンロード

GridDBとSpring Bootによるリアルタイム・インフラ監視

By griddb-adminIn BlogPosted 0 Comment(s)

はじめに

今日の高速かつデータ主導の世界では、アプリケーションとシステムのシームレスな運用が重要な優先事項となっています。ダウンタイムを防ぎ、ユーザーの満足度を維持し、リソースの利用率を最適化するためには、パ フォーマンスの問題を早期に発見し、解決することが重要です。断続的なチェックと断片的なデータ・ソースに依存することが多い従来のモニタリング手法では、最新のアプリケーションのリアルタイム要求に対応するのは困難です。

そこで、リアルタイム・モニタリング・システムの出番となります。これらのアプリケーションは継続的にデータを収集・分析し、システムの健全性とパフォーマンスの包括的なビューを提供します。プロアクティブに異常や潜在的な問題を特定することで、リアルタイム・モニタリングは、迅速な是正措置を取ることを可能にし、中断を最小限に抑え、アプリケーションのアップタイムを保証します。

この記事では、高性能な時系列データベースであるGridDBと、一般的なJavaフレームワークであるSpring Bootを組み合わせて、堅牢なリアルタイムモニタリングシステムを構築する方法を紹介します。GridDBクラスタのセットアップからSpring Bootアプリケーションの設定、アラートメカニズムや通知システムの実装まで、この監視ソリューションの作成に関わる各ステップを概説しながら、実用的なユースケースを掘り下げていきます。

GridDBクラスタのセットアップとSpring Bootの統合： リアルタイムモニタリングのために

リアルタイム監視システムを構築する最初のステップは、強固な基盤を確立することです。これは、GridDBクラスタのセットアップと、Spring BootアプリケーションがGridDBクラスタとシームレスに通信できるように設定することです。

  • GridDBクラスタのセットアップ

GridDBには、様々なニーズに対応できる多様なオプションがあります。開発環境では、ローカルマシン上のシングルノードクラスタで十分かもしれませんが、本番環境では、耐障害性とスケーラビリティを強化するために、複数のマシンに分散したクラスタが有効です。選択したデプロイ戦略に基づくクラスタセットアップの詳細な手順については、GridDBのドキュメントを参照してください。

GridDBクラスタをセットアップするには、こちらの手順に従ってください。

  • Spring Bootアプリケーションのセットアップ

GridDBクラスタが稼働したら、いよいよSpring Bootアプリケーションを接続します。GridDB Java Client APIは、この通信チャネルを確立するための必須ツールを提供する。幸いなことに、griddb-spring-boot-starterのようなライブラリがこのプロセスを簡素化してくれる。このライブラリを依存関係としてプロジェクトに含めることで、接続設定を効率化する事前設定済みのBeanにアクセスできるようになります。

Spring Bootアプリケーションでは、クラスタ名、ホスト名、認証情報などの接続の詳細を設定します。これらの設定は通常、プロパティファイルで定義するか、Spring Bootの設定クラス内で直接定義します。接続が確立されると、Spring BootアプリケーションはGridDBクラスタと対話し、パフォーマンスメトリクスの保存と管理にGridDBの機能を活用できるようになります。

プロジェクトの構成

以下は、このようなアプリケーションの推奨プロジェクト構成です：

.
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── mycode
│   │   │       ├── config
│   │   │       │   └── GridDBConfig.java
│   │   │       ├── dto
│   │   │       │   └── CpuMetric.java
│   │   │       ├── MySpringBootApplication.java
│   │   │       └── service
│   │   │           ├── AlertingService.java
│   │   │           └── MetricsCollectionService.java
│   │   └── resources
│   │       └── application.properties

この構造では、コントローラ、モデル、リポジトリ、サービス、およびアプリケーションのエントリポイントについて、個別のレイヤーを定義し、モジュール性と保守性を促進します。さらに、アプリケーションプロパティやロギング設定などのリソースファイルや、堅牢性を確保するためのテストスイートも含まれます。

GridDB依存性の追加

Spring BootプロジェクトでGridDBとやり取りするには、GridDB Java Client API依存関係をインクルードする必要があります。これは、プロジェクトのビルドファイル（Mavenの場合は pom.xml、Gradleの場合は同等のファイル）に必要な設定を追加することで実現できます。

以下は、pom.xmlファイルに依存関係を設定する方法の例です：

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>my-griddb-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>my-griddb-app</name>
  <url>http://maven.apache.org</url>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.4</version>
    <relativePath /> <!-- lookup parent from repository -->
  </parent>
  <properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.github.griddb/gridstore-jdbc -->
    <dependency>
      <groupId>com.github.griddb</groupId>
      <artifactId>gridstore-jdbc</artifactId>
      <version>5.3.0</version>
    </dependency>
    <dependency>
      <groupId>com.github.griddb</groupId>
      <artifactId>gridstore</artifactId>
      <version>5.5.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
  </dependencies>
</project>

GridDB接続の設定

GridDBの依存関係を追加したら、Spring Bootアプリケーションのプロパティファイル（通常はapplication.propertiesというファイル名）でGridDBクラスタへの接続の詳細を設定します。このファイルでは、様々なアプリケーションの設定を定義できます。

以下は接続設定の例です：

GRIDDB_NOTIFICATION_MEMBER=127.0.0.1:10001
GRIDDB_CLUSTER_NAME=myCluster
GRIDDB_USER=admin
GRIDDB_PASSWORD=admin
management.endpoints.web.exposure.include=*
  • griddb.cluster.host: The hostname or IP address of your GridDB cluster.
  • griddb.cluster.port: The port number on which the GridDB cluster is listening.
  • griddb.cluster.user: The username for accessing the GridDB cluster.
  • griddb.cluster.password: The password for the specified GridDB user (replace with your actual password).

GridDBクライアントBeanを作成する

設定したパラメータを使用してGridDB接続を初期化するSpring Beanを作成します。このBeanは、アプリケーション全体でGridDBクラスタとやり取りするために使用されます。これはGridDbConfig.javaで行います。以下は、Spring BootアプリケーションでGridDBと効率的にやり取りするために、GridDB接続を管理する専用のBeanが必要になります。このBeanは、application.propertiesファイルで指定した設定パラメータを使って接続を初期化します。一度作成されたBeanは、アプリケーション全体でGridDBクラスタとやりとりするための中心的な役割を果たします。

このようなビーンを GridDbConfig.java という Java クラスで定義する例を以下に示します：

package mycode.config;

import java.util.Properties;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import com.toshiba.mwcloud.gs.GSException;
import com.toshiba.mwcloud.gs.GridStore;
import com.toshiba.mwcloud.gs.GridStoreFactory;

@Configuration
@PropertySource("classpath:application.properties")
public class GridDBConfig {

  @Value("${GRIDDB_NOTIFICATION_MEMBER}")
  private String notificationMember;

  @Value("${GRIDDB_CLUSTER_NAME}")
  private String clusterName;

  @Value("${GRIDDB_USER}")
  private String user;

  @Value("${GRIDDB_PASSWORD}")
  private String password;

  @Bean
  public GridStore gridStore() throws GSException {
    // Acquiring a GridStore instance
    Properties properties = new Properties();
    properties.setProperty("notificationMember", notificationMember);
    properties.setProperty("clusterName", clusterName);
    properties.setProperty("user", user);
    properties.setProperty("password", password);
    return GridStoreFactory.getInstance().getGridStore(properties);
  }
}

メトリクス収集

GridDBとSpring Bootの統合で基礎を固めたので、次はデータ収集とスキーマ設計の重要な側面に踏み込もう。これらのステップでは、監視するパフォーマンスメトリクスの構造と構成を定義する。

シームレスなメトリクス収集のためのSpring Actuatorの活用

Spring Boot Actuatorは、様々なエンドポイントを公開することでアプリケーションの監視を簡素化する強力なツールです。これらのエンドポイントは、アプリケーションの健全性、パフォーマンス、設定に関する貴重な洞察を提供する。私たちのシナリオでは、Spring Actuatorは主要なパフォーマンスメトリクスの収集のための主要なソースとして機能します。Spring Actuatorの関連エンドポイントと統合することで、Spring Bootアプリケーションは以下のような重要なデータポイントを収集できます：

  • メモリ使用量（ヒープ、非ヒープ）
  • ガベージコレクション活動
  • CPU使用率
  • スレッド・プールの統計
  • HTTPリクエストの待ち時間とエラー率

この例では、Spring BootアプリケーションのCPU使用率メトリクスにアクセスする方法を示します。

Spring Boot Actuatorはアプリケーションを監視・管理するための様々なエンドポイントを公開しています。そのようなエンドポイントの1つである /actuator/metrics/system.cpu.usage は、アプリケーションが動作しているシステムのCPU使用率に関するデータを提供します。このエンドポイントは通常、CPU使用率をパーセント値で含むJSON応答を返します。

CPU使用率エンドポイントを含むすべてのアクチュエータエンドポイントにアクセスするには、Spring Bootの設定を調整する必要があるかもしれません。以下のプロパティをapplication.propertiesファイルに追加することで、すべてのアクチュエータエンドポイントを公開できます：

management.endpoints.web.exposure.include=*

設定が完了したら、Postmanのようなツールを使うか、以下のURLに直接HTTP GETリクエストを送ることで、CPU使用率のエンドポイントにアクセスできる：

http://localhost:<port>/actuator/metrics/system.cpu.usage

`はSpring Bootアプリケーションが動作している実際のポート番号に置き換えてください。このエンドポイントは通常、CPU使用率の詳細を含むJSONレスポンスを返します。

レスポンスの正確なフォーマットはSpring Bootのバージョンや設定によって異なるかもしれません。しかし、通常はCPU使用率をパーセンテージで返します。

{
  "name": "system.cpu.usage",
  "measurements": [
    {
      "statistic": "VALUE",
      "value": 0.25
    }
  ],
  "availableTags": []
}

スケジュールされたタスクの実行

あらかじめ定義された間隔でモニタリングを行うためには、スプリングスケジューラアプローチを利用する必要がある。これらのタスクは、アプリケーションログ、システムメトリクス、外部APIなど様々なソースからパフォーマンスメトリクスを収集し、分析のためにGridDBに保存します。

Spring Bootにはビルトインのスケジューリング機構があり、事前に定義した間隔でタスクを自動化できる。ここでは、スケジュールされたタスクを活用して、パフォーマンスメトリクスの収集とGridDBへの保存を行い、さらに分析を行う。

タスク機能:

スケジュールされたタスクは次のような責任を負う

  • パフォーマンス指標の収集: これらのメトリクスは、アプリケーション・ログ、システム・メトリクス（CPU使用率など）、外部APIなど、さまざまなソースから取得できます。
  • GridDBにデータを保存する: 収集されたメトリクスは処理され、効率的な分析のためにGridDBに保存される。
package mycode.service;

import java.util.Date;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.toshiba.mwcloud.gs.*;

import mycode.dto.CpuMetric;

@Service
public class MetricsCollectionService {
  @Autowired
  GridStore store;

  @Scheduled(fixedRate = 6000) // Collect metrics every minute
  public void collectMetrics() throws GSException {
    // Fetch CPU usage metrics from Spring Boot Actuator endpoint
    double cpuUsage = getCPUUsageFromActuator();
    Date timestamp = new Date();

    // Create a CPU metric object
    CpuMetric cpuMetric = new CpuMetric(timestamp, cpuUsage);

    // Store the metric in GridDB
    System.out.println("Fetching CPU metrics at current time");
    TimeSeries<cpumetric> ts = store.putTimeSeries("cpuMetrics", CpuMetric.class);
    ts.append(cpuMetric);
  }

  private double getCPUUsageFromActuator() {
    String actuatorUrl = "http://localhost:8080/actuator/metrics/system.cpu.usage";
    RestTemplate restTemplate = new RestTemplate();
    try {
      ResponseEntity<string> responseEntity = restTemplate.getForEntity(actuatorUrl, String.class);

      if (responseEntity.getStatusCode() == HttpStatus.OK) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode root = mapper.readTree(responseEntity.getBody());
        JsonNode measurements = root.path("measurements");

        if (measurements.isArray() && measurements.size() > 0) {
          JsonNode valueNode = measurements.get(0).path("value");
          if (valueNode.isDouble())
            return valueNode.asDouble();
        }
      }
    } catch (HttpClientErrorException e) {
      // Handle HTTP client errors
      System.err.println("HTTP error: " + e.getMessage());
    } catch (Exception e) {
      // Handle other exceptions
      System.err.println("Error: " + e.getMessage());
    }

    // Return a default value if unable to fetch or parse the CPU usage
    return -1.0;
  }
}</string></cpumetric>

GridDBに処理データを格納します: パフォーマンス・メトリクスを効率的に格納するために、GridDB内に専用のスキーマを定義します。

以下は、CPU使用率データを表すCpuMetricというスキーマクラスの例です：

package mycode.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;

import com.toshiba.mwcloud.gs.RowKey;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class CpuMetric {
  @RowKey
  public Date timestamp;
  public double cpuUsage;
}

GridDBによる動的CPU使用量しきい値

従来のCPU監視では、静的な閾値に依存することが多く、誤検知や重要な状況を見逃す危険性があります。このセクションでは、GridDBに保存された履歴データに基づいてCPU使用率のしきい値を設定する動的なアプローチを検討します。

このアプローチでは、動的閾値の手法を利用して、履歴データに基づいて CPU 使用率を計算します。まず、GridDB から過去の CPU メトリクスを取得します。次に、このデータを処理し、総CPU使用率やデータポイントの数などの集計メトリックスを計算します。これにより、指定された期間の平均CPU使用率を計算することができます。最後に、過去の傾向と偏差を活用して、現在のシステム状態に合わせた動的な閾値を決定します。このアプローチにより、システムの変動に対する適応性が保証され、CPU の異常な動作に対するプロアクティブな監視とアラートが容易になります。

calculateDynamicThresholdメソッドは、GridDBに保存された過去のCPUメトリクスを分析し、CPU使用率に適した閾値を動的に決定することで、システムの健全性を監視する上で重要な役割を果たします。

package mycode.service;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import com.toshiba.mwcloud.gs.Container;
import com.toshiba.mwcloud.gs.GridStore;
import com.toshiba.mwcloud.gs.Query;
import com.toshiba.mwcloud.gs.Row;
import com.toshiba.mwcloud.gs.RowSet;

import mycode.dto.CpuMetric;

@Service
public class AlertingService {

  private final double cpuUsageThreshold = 90.0; // CPU usage threshold in percentage
  @Autowired
  GridStore store;

  @Scheduled(fixedRate = 60000) // Check metrics every minute
  public void monitorAndAlert() throws Exception {
    // Fetch the latest CPU metric from GridDB

    double currentThreshold = c sendAlertOException ex) {
      ex.printStackTrace();
    }
  }

  private double calculateDynamicThreshold() throws Exception {

    Container container = store.getContainer("cpuMetrics");
    if (container == null) {
      throw new Exception("Container not found.");
    }

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
    Date now = new Date();
    Date sixHoursAgo = new Date(now.getTime() - TimeUnit.HOURS.toMillis(6));

    String nowString = dateFormat.format(now);
    String sixHoursAgoString = dateFormat.format(sixHoursAgo);

    String queryString = "select * where timestamp >= TIMESTAMP('" + sixHoursAgoString
        + "') and timestamp <= TIMESTAMP('" + nowString + "')";
    System.out.println(queryString);
    Query<row> query = container.query(queryString);
    // Fetch the results using RowSet
    RowSet</row><row> rs = query.fetch();

    // Process the fetched CPU metrics
    double totalCpuUsage = 0.0;
    int count = 0;
    while (rs.hasNext()) {
      Row row = rs.next();
      Double cpuUsage = row.getDouble(1);
      totalCpuUsage += cpuUsage;
      count++;
      System.out
          .println("Timestamp: " + row.getTimestamp(0) + ", CPU Usage: " + row.getDouble(1));
    }

    // Calculate the average CPU usage over the past six hours
    double averageCpuUsage = (count > 0) ? (totalCpuUsage / count) : 0.0;

    // Perform additional calculations based on averageCpuUsage and return the
    // result
    double dynamicThreshold = calculateThreshold(averageCpuUsage);

    return dynamicThreshold;
  }

  private double calculateThreshold(double averageCpuUsage) {
    return averageCpuUsage * 1.2;
  }

}</row>

継続監視モジュールによってメトリック違反が検出されると、Spring Bootアプリケーションは関連情報をカプセル化したアラートオブジェクトを生成する必要があります。このオブジェクトには通常、次のような詳細が含まれます：

  • Metric Name:しきい値を超えた特定のメトリック
  • Threshold Violated:超過した特定の閾値
  • Current Value: 違反時のメトリックの実際の値
  • Timestamp: 違反が発生した正確な時刻

TsendAlert()メソッドでSendGridのようなサードパーティのAPIを使ってメールを送信するには、まずSendGrid Javaライブラリをプロジェクトに統合する必要があります。sendAlertメソッドは、SendGridのようなサードパーティのAPIを利用してメール通知を行うことができます。これを実現するには、SendGrid Javaライブラリをプロジェクトに統合する必要があります。以下はその方法です：

  • SendGrid の依存関係を pom.xml に追加します：
  <dependency>
      <groupId>com.sendgrid</groupId>
      <artifactId>sendgrid-java</artifactId>
      <version>4.8.0</version>
  </dependency>
  • SendGridのAPIキーとその他のプロパティをapplication.propertiesで設定します：
sendgrid.api.key=YOUR_SENDGRID_API_KEY
  • SendGrid を使用して sendAlert() メソッドを実装します：
  public void sendAlert(double cpuUsage) {
    Email from = new Email("your@example.com");
    String subject = "CPU Alert - High CPU Usage Detected";
    Email to = new Email("admin@example.com");
    Content content = new Content("text/plain",
        "CPU usage has exceeded the threshold." + cpuUsage + "at" + Instant.now());
    Mail mail = new Mail(from, subject, to, content);

    SendGrid sg = new SendGrid(sendGridApiKey);
    Request request = new Request();
    try {
      request.setMethod(Method.POST);
      request.setEndpoint("mail/send");
      request.setBody(mail.build());
      Response response = sg.api(request);
      System.out.println(response.getStatusCode());
      System.out.println(response.getBody());
      System.out.println(response.getHeaders());
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }

これで、以下のようなメールが送信されます：

プロジェクトの実行

プロジェクトを実行するには、以下のコマンドを実行してアプリケーションをビルドし、実行します：

mvn clean install && mvn spring-boot:run

コマンドの実行に成功すると、ターミナル・ウィンドウに以下のような出力が表示されるはずだ：

[INFO] Attaching agents: []
SLF4J(W): Class path contains multiple SLF4J providers.
SLF4J(W): Found provider [ch.qos.logback.classic.spi.LogbackServiceProvider@5fa7e7ff]
SLF4J(W): Found provider [org.slf4j.jul.JULServiceProvider@4629104a]
SLF4J(W): See https://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J(I): Actual provider is of type [ch.qos.logback.classic.spi.LogbackServiceProvider@5fa7e7ff]

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::             my-griddb-app)
2024-04-05T16:55:48.101+05:30  INFO 1271 --- [           main] mycode.MySpringBootApplication           : No active profile set, falling back to 1 default profile: "default"
2024-04-05T16:55:50.941+05:30  INFO 1271 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2024-04-05T16:55:50.971+05:30  INFO 1271 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2024-04-05T16:55:50.971+05:30  INFO 1271 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.19]
2024-04-05T16:55:51.092+05:30  INFO 1271 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2024-04-05T16:55:51.093+05:30  INFO 1271 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 2876 ms
2024-04-05T16:55:53.025+05:30  INFO 1271 --- [           main] o.s.b.a.e.web.EndpointLinksResolver      : Exposing 13 endpoint(s) beneath base path '/actuator'
2024-04-05T16:55:53.143+05:30  INFO 1271 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path ''
2024-04-05T16:55:53.163+05:30  INFO 1271 --- [           main] mycode.MySpringBootApplication           : Started MySpringBootApplication in 6.047 seconds (pr24-04-05T16:55:53.328Z')
2024-04-05T16:55:53.647+05:30  INFO 1271 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2024-04-05T16:55:53.648+05:30  INFO 1271 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2024-04-05T16:55:53.649+05:30  INFO 1271 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
Fetching CPU metrics at current time
Fetching CPU metrics at current time
Fetching CPU metrics at current time
Fetching CPU metrics at current time
Fetching CPU metrics at current time
Timestamp: Fri Apr 05 16:55:59 IST 2024, CPU Usage: 0.004949328305444261
Timestamp: Fri Apr 05 16:56:05 IST 2024, CPU Usage: 0.0020863759649488835
Timestamp: Fri Apr 05 16:56:11 IST 2024, CPU Usage: 0.001875390706397166
Timestamp: Fri Apr 05 16:56:17 IST 2024, CPU Usage: 0.001665972511453561
Timestamp: Fri Apr 05 16:56:23 IST 2024, CPU Usage: 0.001669449081803005
Timestamp: Fri Apr 05 16:56:29 IST 2024, CPU Usage: 6.253908692933083E-4
Timestamp: Fri Apr 05 16:56:35 IST 2024, CPU Usage: 0.0016677089847821555
Timestamp: Fri Apr 05 16:56:41 IST 2024, CPU Usage: 0.0010412328196584756
Timestamp: Fri Apr 05 16:56:47 IST 2024, CPU Usage: 6.264355815410315E-4hing CPU metrics at current time

CPU使用率が動的に計算されたしきい値を超えると、sendAlertメソッドがトリガーされます。このメソッドは前述したように、SendGridのようなサードパーティのAPIを利用して、CPUオーバーロードの可能性に関する通知メールを送信することができます。

**GridDBにおけるデータストレージ

リアルタイム監視のためにアラートが送信される一方で、収集されたCPUメトリクスは、履歴分析や将来の参照のために、内部のGridDBインスタンスに継続的に保存されます。このデータへのアクセスやクエリは、以下のように GridDB Shell ツールを使用して行うことができます。

$ gs_sh
Loading "/var/lib/gridstore/.gsshrc"
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/java/griddb-cli.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/gridstore/lib/logback-classic-1.0.13.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [ch.qos.logback.classic.util.ContextSelectorStaticBinder]
The connection attempt was successful(NoSQL).
The connection attempt was successful(NewSQL).
gs[public]> SELECT * FROM cpuMetrics;
65 results. (14 ms)
gs[public]> get 65
+--------------------------+-----------------------+
| Timestamp                | CpuUsage              |
+--------------------------+-----------------------+
| 2024-04-03T18:37:16.331Z | 0.0048760521050437682 |
| 2024-04-05T11:27:23.156Z | 8.333333333333334E-4  |
| 2024-04-05T11:27:29.073Z | 8.347245409015025E-4  |
| 2024-04-05T11:27:35.091Z | 8.340283569641367E-4  |
| 2024-04-05T11:27:41.107Z | 6.256517205422314E-4  |
| 2024-04-05T11:27:47.123Z | 0.0010444955086693127 |
| 2024-04-05T11:27:53.137Z | 8.335069806209627E-4  |
| 2024-04-05T11:27:59.153Z | 6.255212677231026E-4  |
| 2024-04-05T11:28:05.070Z | 4.1718815185648727E-4 |
| 2024-04-05T11:28:11.086Z | 6.256517205422315E-4  |
| 2024-04-05T11:28:17.097Z | 6.252605252188412E-4  |
| 2024-04-05T11:28:23.109Z | 0.0012513034410844628 |
| 2024-04-05T11:28:29.125Z | 0.0025010421008753647 |
| 2024-04-05T11:28:35.141Z | 0.004586199708150928  |
| 2024-04-05T11:28:41.154Z | 0.01920267167605928   |
| 2024-04-05T11:28:47.069Z | 0.0018769551616266945 |
| 2024-04-05T11:28:53.334Z | 0.0018575851393188856 |
| 2024-04-05T11:28:59.149Z | 0.0021235931195582925 |
| 2024-04-05T11:29:05.166Z | 0.0014583333333333334 |
| 2024-04-05T11:29:11.083Z | 0.0022921441967076474 |
| 2024-04-05T11:29:17.099Z | 0.002082032063293775  |
| 2024-04-05T11:29:23.116Z | 8.350730688935282E-4  |
| 2024-04-05T11:29:29.132Z | 6.256517205422314E-4  |
| 2024-04-05T11:29:35.148Z | 8.338544923910778E-4  |
| 2024-04-05T11:29:41.162Z | 0.001043187982474442  |
| 2024-04-05T11:29:47.077Z | 0.0014601585314977055 |
| 2024-04-05T11:29:53.093Z | 0.004372267332916927  |
| 2024-04-05T11:29:59.111Z | 0.0010438413361169101 |
| 2024-04-05T11:30:05.125Z | 0.0012505210504376823 |
| 2024-04-05T11:30:11.142Z | 0.0010423181154888472 |
| 2024-04-05T11:30:17.155Z | 0.01943979933110368   |
| 2024-04-05T11:30:23.070Z | 0.0014595496246872393 |
| 2024-04-05T11:30:29.086Z | 8.340283569641367E-4  |
| 2024-04-05T11:30:35.231Z | 0.002073828287017835  |
+--------------------------+-----------------------+
The 65 results had been acquired.

結論:

要約すると、GridDBとSpring Bootの統合は、最新のアプリケーションにおけるリアルタイムモニタリングとアラートのための強力なソリューションを提供します。GridDBの高性能JavaクライアントAPIを活用することで、開発者は主要なパフォーマンスメトリクスの保存とクエリを効率的に行うことができます。Spring Bootの堅牢なフレームワークと組み合わせることで、この統合は継続的なモニタリングの実装と、応答性の高い通知システムの開発を容易にします。

効率的なスキーマ設計と動的構成により、開発者は監視ソリューションを特定のニーズに合わせてカスタマイズでき、異常のタイムリーな検出と解決を確実にします。電子メール、SMS、Slackの通知サービスを統合する機能により、関係者は常に情報を入手し、重要なイベントに迅速に対応することができます。

要するに、GridDBとSpring Bootは、開発者が俊敏で信頼性の高い監視システムを構築することを可能にし、アプリケーションの信頼性、パフォーマンス、そして今日のペースの速いデジタル環境におけるユーザーの満足度を向上させます。

ブログの内容について疑問や質問がある場合は Q&A サイトである Stack Overflow に質問を投稿しましょう。 GridDB 開発者やエンジニアから速やかな回答が得られるようにするためにも "griddb" タグをつけることをお忘れなく。 https://stackoverflow.com/questions/ask?tags=griddb

griddb-admin

griddb-admin

Leave a Reply

Your email address will not be published. Required fields are marked *