Crate conreg_client 

Conreg Client

Conreg is a distributed service registry and configuration center designed with reference to Nacos. See details: conreg

conreg-client is the client SDK for conreg, used to integrate into your services and communicate with conreg-server.

Quick Start

Basic Usage

Add a bootstrap.yaml configuration file in your project’s root directory:

conreg:
  # Service ID is the unique identifier of the service. Service IDs in the same namespace cannot be duplicated.
  service-id: test
  # Client configuration, this information will be submitted to the registry as basic information of the service instance
  client:
    # Listening address
    address: 127.0.0.1
    # Port
    port: 8000
  # Configuration center configuration
  config:
  # Configuration center address
    server-addr: 127.0.0.1:8000
    # Configuration ID
    # If there are duplicate configuration keys in multiple configurations, the latter configuration will overwrite the previous one
    config-ids:
      - test.yaml
    auth-token: your_token
  # Registry configuration
  discovery:
    # Registry address
    server-addr:
      - 127.0.0.1:8000
      - 127.0.0.1:8001
      - 127.0.0.1:8002
    auth-token: your_token

Then, initialize in the main function:

#[tokio::main]
async fn main() {
    // Initialization
    init().await;
    // Get configuration item
    println!("{:?}", AppConfig::get::<String>("name"));
    // Get service instances
    let instances = AppDiscovery::get_instances("your_service_id").await.unwrap();
    println!("service instances: {:?}", instances);
}

Namespace

Conreg uses namespaces to isolate configurations and services. The default namespace is public.

Configuration Center

Load and use configurations from the configuration center. Currently only yaml format configurations are supported.

Initialize and Load Configuration

#[tokio::main]
async fn main() {
    init_with(
        ConRegConfigBuilder::default()
            .config(
                ConfigConfigBuilder::default()
                    .server_addr("127.0.0.1:8000")
                    .namespace("public")
                    .config_ids(vec!["test.yaml".into()])
                    .build()
                    .unwrap(),
            )
            .build()
            .unwrap(),
    )
        .await;
    println!("{:?}", AppConfig::get::<String>("name"));
    println!("{:?}", AppConfig::get::<u32>("age"));
}

Initialize from Configuration File

By default, conreg-client loads configurations from the bootstrap.yaml file in the project root directory to initialize configurations, just like SpringCloud. The following is an example of bootstrap.yaml configuration:

conreg:
  config:
    server-addr: 127.0.0.1:8000
    config-ids:
      - your_config.yaml

Then call the init method to initialize and get the configuration content.

#[tokio::main]
async fn main() {
    init().await;
    // Or specify the configuration file path
    // init_from_file("config.yaml").await;
    println!("{:?}", AppConfig::get::<String>("name"));
    println!("{:?}", AppConfig::get::<u32>("age"));
}

Registry Center

Used for service registration and discovery.

Initialize and Load Configuration

#[tokio::main]
async fn main() {
    let config = ConRegConfigBuilder::default()
        .service_id("your_service_id")
        .client(
            ClientConfigBuilder::default()
                .address("127.0.0.1")
                .port(8080)
                .build()
                .unwrap(),
        )
        .discovery(
            DiscoveryConfigBuilder::default()
                .server_addr("127.0.0.1:8000")
                .build()
                .unwrap(),
        )
        .build()
        .unwrap();
    let service_id = config.service_id.clone();
    init_with(config).await;
    let instances = AppDiscovery::get_instances(&service_id).await.unwrap();
    println!("service instances: {:?}", instances);
}

Initialize from Configuration File

By default, configurations are loaded from bootstrap.yaml. The following is an example configuration:

conreg:
  service-id: your_service_id
  client:
    address: 127.0.0.1
    port: 8000
  discovery:
    server-addr:
      - 127.0.0.1:8000
      - 127.0.0.1:8001
      - 127.0.0.1:8002

#[tokio::main]
async fn main() {
    init().await;
    // Or specify the configuration file path
    // init_from_file("config.yaml").await;
    init_with(config).await;
    let service_id = "your_service_id";
    let instances = AppDiscovery::get_instances(service_id).await.unwrap();
    println!("service instances: {:?}", instances);
}

Load Balancing

conreg-client provides a load balancing client based on reqwest, supporting custom protocol requests in the format lb://service_id. Reference: lb

Listen for Configuration Changes

Add a handler function for the specified config_id, which will be called when the configuration changes.

AppConfig::add_listener("test.yaml", |config| {
println!("Config changed, new config: {:?}", config);
});

Modules

conf

lb

Load Balance Component

Structs

AppConfig

Application Configuration

AppDiscovery

Service Discovery

Instance

Service Instance

Functions

init

Initialize configuration center and registry center

init_from_file

Initialize configuration center and registry center from configuration file

init_with

Initialize from custom configuration