Config

    • The local file data source is implemented by default
    • Users can customize the data source implementation
    • Supports configuration hot-reloading, and change the existing Value through Atomic
    • Supports custom data-source decoding implementation
    • Ability to get the value of environment variables or existing fields through the $ placeholder

    In the Kratos project, we recommend using proto to define the configuration file by default. The main benefits are:

    • A unified template configuration can be defined
    • Add corresponding configuration verification
    • Better management of configuration
    • Cross-language support

    Configuration file

    Proto declaration

    1. syntax = "proto3";
    2. package kratos.api;
    4. option go_package = "github.com/go-kratos/kratos-layout/internal/conf;conf";
    6. import "google/protobuf/duration.proto";
    8. message Bootstrap {
    9.   Server server = 1;
    10.   Data data = 2;
    11. }
    13. message Server {
    14.   message HTTP {
    15.     string network = 1;
    16.     string addr = 2;
    17.     google.protobuf.Duration timeout = 3;
    18.   }
    19.   message GRPC {
    20.     string network = 1;
    21.     string addr = 2;
    22.     google.protobuf.Duration timeout = 3;
    23.   HTTP http = 1;
    24.   GRPC grpc = 2;
    25. }
    27. message Data {
    28.   message Database {
    30.     string source = 2;
    31.   }
    32.   message Redis {
    33.     string network = 1;
    34.     string addr = 2;
    35.     google.protobuf.Duration read_timeout = 3;
    36.     google.protobuf.Duration write_timeout = 4;
    37.   }
    38.   Database database = 1;
    39.   Redis redis = 2;
    40. }

    One or more config sources can be applied.

    • file
    • env
    1. c := config.New(
    2.     config.WithSource(
    3.         file.NewSource(path),
    4.     ),
    5.     config.WithDecoder(func(kv *config.KeyValue, v map[string]interface{}) error {
    6.         // kv.Key
    7.         // kv.Value
    8.         // kv.Metadata
    9.         // Configuration center can use the metadata to determine the type of the config.
    10.         return yaml.Unmarshal(kv.Value, v)
    11.     }),
    12.     config.WithResolver(func(map[string]interface{}) error {
    13.         // The default resolver provides processing
    14.         // for two $(key:default) and $key placeholders.
    15.         //
    16.         // Customize the processing method after loading the configuration data...
    17. )
    18. // load config source
    20.     log.Fatal(err)
    21. }
    22. // Get the corresponding value
    23. name, err := c.Value("service").String()
    25. /*
    26.   // The structure generated by the proto file can also be directly declared for analysis
    27.   var v struct {
    28.       Service string `json:"service"`
    29.       Version string `json:"version"`
    30.   }
    31. */
    32. var bc conf.Bootstrap
    33. if err := c.Scan(&bc); err != nil {
    34.     log.Fatal(err)
    35. }
    36. // watch the changing of the value
    37. c.Watch("service.name", func(key string, value config.Value) {
    38.     // callback of this event
    39. })

    Kratos can read the value of environment variable or existing field through placeholders in the configuration file

    1. c := config.New(
    2.     config.WithSource(
    3.         // Add environment variables prefixed with KRATOS_
    4.         env.NewSource("KRATOS_"),
    5.         // Add configuration file
    6.         file.NewSource(path),
    7.     ))
    9. // 加载配置源:
    10. if err := c.Load(); err != nil {
    11.     log.Fatal(err)
    12. }
    14. port, err := c.Value("PORT").String()