4.0.5

Spring Cloud Config は、分散システムの外部設定に対してサーバー側とクライアント側のサポートを提供します。設定サーバーを使用すると、すべての環境にわたるアプリケーションの外部プロパティを管理するための中心的な場所が得られます。クライアントとサーバーの両方の概念は、Spring Environment および PropertySource 抽象化と同じようにマップされるため、Spring アプリケーションに非常によく適合しますが、任意の言語で実行されている任意のアプリケーションで使用できます。アプリケーションがデプロイパイプラインを介して開発からテスト、本番環境に移動するときに、これらの環境間の設定を管理し、アプリケーションが移行時に実行するために必要なすべてのものを備えていることを確認できます。サーバーストレージバックエンドのデフォルトの実装は git を使用するため、ラベル付きバージョンの設定環境を簡単にサポートし、コンテンツを管理するためのさまざまなツールにアクセスできます。代替の実装を追加して、Spring 設定でプラグインするのは簡単です。

クイックスタート

このクイックスタートでは、Spring Cloud Config サーバーのサーバーとクライアントの両方を使用して説明します。

まず、次のようにサーバーを起動します。

$ cd spring-cloud-config-server
$ ../mvnw spring-boot:run

サーバーは Spring Boot アプリケーションであるため、必要に応じて IDE から実行できます(メインクラスは ConfigServerApplication です)。

次に、次のようにクライアントを試してください。

$ curl localhost:8888/foo/development
{
  "name": "foo",
  "profiles": [
    "development"
  ]
  ....
  "propertySources": [
    {
      "name": "https://github.com/spring-cloud-samples/config-repo/foo-development.properties",
      "source": {
        "bar": "spam",
        "foo": "from foo development"
      }
    },
    {
      "name": "https://github.com/spring-cloud-samples/config-repo/foo.properties",
      "source": {
        "foo": "from foo props",
        "democonfigclient.message": "hello spring io"
      }
    },
    ....

プロパティソースを見つけるためのデフォルトの戦略は、git リポジトリ(spring.cloud.config.server.git.uri)のクローンを作成し、それを使用してミニ SpringApplication を初期化することです。ミニアプリケーションの Environment は、プロパティソースを列挙し、JSON エンドポイントで公開するために使用されます。

HTTP サービスには、次の形式のリソースがあります。

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

例:

curl localhost:8888/foo/development
curl localhost:8888/foo/development/master
curl localhost:8888/foo/development,db/master
curl localhost:8888/foo-development.yml
curl localhost:8888/foo-db.properties
curl localhost:8888/master/foo-db.properties

ここで、application は SpringApplication (通常の Spring Boot アプリでは通常 application)に spring.config.name として挿入され、profile はアクティブなプロファイル(またはプロパティのコンマ区切りリスト)であり、label はオプションの git ラベルです。(デフォルトは master です。)

Spring Cloud Config サーバーは、さまざまなソースからリモートクライアントの構成をプルします。次の例は、次の例に示すように、git リポジトリ(提供する必要があります)から構成を取得します。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo

その他のソースは、JDBC 互換データベース、Subversion、Hashicorp Vault、Credhub、ローカルファイルシステムです。

クライアント側の使用箇所

これらの機能をアプリケーションで使用するには、spring-cloud-config-client に依存する Spring Boot アプリケーションとしてビルドできます(たとえば、config-client またはサンプルアプリケーションのテストケースを参照してください)。依存関係を追加する最も便利な方法は、Spring Boot スターター org.springframework.cloud:spring-cloud-starter-config を使用することです。Maven ユーザー用の親 pom および BOM(spring-cloud-starter-parent)と、Gradle および Spring CLI ユーザー用の Spring IO バージョン管理プロパティファイルもあります。次の例は、一般的な Maven 構成を示しています。

pom.xml
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>{spring-boot-docs-version}</version>
       <relativePath /> <!-- lookup parent from repository -->
   </parent>

<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>
	</dependencies>
</dependencyManagement>

<dependencies>
	<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-config</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
</dependencies>

<build>
	<plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
	</plugins>
</build>

   <!-- repositories also needed for snapshots and milestones -->

これで、次の HTTP サーバーなどの標準 Spring Boot アプリケーションを作成できます。

@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String home() {
        return "Hello World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

この HTTP サーバーが実行されると、ポート 8888 でデフォルトのローカル構成サーバー(実行中の場合)から外部構成が取得されます。起動動作を変更するには、に示すように application.properties を使用して構成サーバーの場所を変更できます。次の例:

spring.config.import=optional:configserver:http://myconfigserver.com

デフォルトでは、アプリケーション名が設定されていない場合、application が使用されます。名前を変更するには、次のプロパティを application.properties ファイルに追加できます。

spring.application.name: myapp
プロパティ ${spring.application.name} を設定するときは、正しいプロパティソースを解決する際の課題を防ぐために、アプリ名の前に予約語 application- を付けないでください。

次の例に示すように、構成サーバーのプロパティは、優先度の高いプロパティソースとして /env エンドポイントに表示されます。

$ curl localhost:8080/env
{
  "activeProfiles": [],
  {
    "name": "servletContextInitParams",
    "properties": {}
  },
  {
    "name": "configserver:https://github.com/spring-cloud-samples/config-repo/foo.properties",
    "properties": {
      "foo": {
        "value": "bar",
        "origin": "Config Server https://github.com/spring-cloud-samples/config-repo/foo.properties:2:12"
      }
    }
  },
  ...
}

configserver:<URL of remote repository>/<file name> と呼ばれるプロパティソースには、bar の値を持つ foo プロパティが含まれています。

プロパティソース名の URL は、構成サーバーの URL ではなく、git リポジトリです。
Spring Cloud Config クライアントを使用する場合は、ConfigServer にバインドするために spring.config.import プロパティを設定する必要があります。詳細については、Spring Cloud Config リファレンスガイドを参照してください

Spring Cloud Config サーバー

Spring Cloud Config サーバーは、外部構成(名前と値のペアまたは同等の YAML コンテンツ)用の HTTP リソースベースの API を提供します。サーバーは、@EnableConfigServer アノテーションを使用して、Spring Boot アプリケーションに埋め込むことができます。次のアプリケーションは構成サーバーです。

ConfigServer.java
@SpringBootApplication
@EnableConfigServer
public class ConfigServer {
  public static void main(String[] args) {
    SpringApplication.run(ConfigServer.class, args);
  }
}

すべての Spring Boot アプリケーションと同様に、デフォルトではポート 8080 で実行されますが、さまざまな方法で従来のポート 8888 に切り替えることができます。デフォルトの構成リポジトリも設定する最も簡単な方法は、spring.config.name=configserver で起動することです(構成サーバー jar には configserver.yml があります)。もう 1 つは、次の例に示すように、独自の application.properties を使用することです。

application.properties
server.port: 8888
spring.cloud.config.server.git.uri: file://${user.home}/config-repo

ここで、${user.home}/config-repo は YAML ファイルとプロパティファイルを含む git リポジトリです。

Windows では、ドライブプレフィックス(file:///${user.home}/config-repo など)が絶対に付いている場合は、ファイル URL に追加の "/" が必要です。

次のリストは、前の例で git リポジトリを作成するためのレシピを示しています。

$ cd $HOME
$ mkdir config-repo
$ cd config-repo
$ git init .
$ echo info.foo: bar > application.properties
$ git add -A .
$ git commit -m "Add application.properties"
git リポジトリにローカルファイルシステムを使用することは、テストのみを目的としています。サーバーを使用して、本番環境で構成リポジトリをホストする必要があります。
構成リポジトリの初期クローンは、テキストファイルのみを保持する場合、迅速かつ効率的になります。バイナリファイル、特に大きなファイルを保存する場合、最初の構成リクエストで遅延が発生したり、サーバーでメモリ不足エラーが発生したりする可能性があります。

環境リポジトリ

構成サーバーの構成データをどこに保存する必要がありますか? この動作を管理する戦略は EnvironmentRepository であり、Environment オブジェクトを提供します。この Environment は、Spring Environment (主な機能として propertySources を含む)からのドメインの浅いコピーです。Environment リソースは、次の 3 つの変数によってパラメーター化されます。

  • {application}。これはクライアント側の spring.application.name にマップされます。

  • {profile}。これはクライアント上の spring.profiles.active にマップされます(コンマ区切りリスト)。

  • {label} は、構成ファイルの「バージョン管理された」セットにラベルを付けるサーバー側の機能です。

リポジトリの実装は通常、Spring Boot アプリケーションのように動作し、{application} パラメーターに等しい spring.config.name{profiles} パラメーターに等しい spring.profiles.active から構成ファイルをロードします。プロファイルの優先順位ルールも通常の Spring Boot アプリケーションと同じです。アクティブなプロファイルがデフォルトよりも優先され、複数のプロファイルがある場合は、最後のプロファイルが優先されます(Map へのエントリの追加と同様)。

次のサンプルクライアントアプリケーションには、このブートストラップ構成があります。

spring:
  application:
    name: foo
  profiles:
    active: dev,mysql

(Spring Boot アプリケーションでは通常どおり、これらのプロパティは環境変数またはコマンドライン引数によって設定することもできます)。

リポジトリがファイルベースの場合、サーバーは application.yml (すべてのクライアント間で共有)と foo.yml (foo.yml が優先)から Environment を作成します。YAML ファイル内に Spring プロファイルを指すドキュメントが含まれている場合、(リストされているプロファイルの順序で)より高い優先順位で適用されます。プロファイル固有の YAML(またはプロパティ)ファイルがある場合、これらもデフォルトよりも高い優先順位で適用されます。優先順位が高いほど、Environment で前述した PropertySource に変換されます。(これらの同じルールは、スタンドアロンの Spring Boot アプリケーションにも適用されます。)

アプリケーションが見つからない場合にサーバーが HTTP 404 ステータスを返すように、spring.cloud.config.server.accept-empty を false に設定できます。デフォルトでは、このフラグは true に設定されます。

spring.main.* プロパティを リモート EnvironmentRepository に配置することはできません。これらのプロパティは、アプリケーションの初期化の一部として使用されます。

Git バックエンド

EnvironmentRepository のデフォルトの実装では、Git バックエンドを使用します。これは、アップグレードや物理環境の管理、および変更の監査に非常に便利です。リポジトリの場所を変更するには、構成サーバー(たとえば、application.yml)で spring.cloud.config.server.git.uri 構成プロパティを設定できます。file: プレフィックスを付けて設定すると、サーバーがなくてもすばやく簡単に開始できるように、ローカルリポジトリから機能するはずです。ただし、その場合、サーバーはクローンを作成せずにローカルリポジトリで直接動作します(構成サーバーが「リモート」リポジトリに変更を加えることはないため、サーバーが裸でなくても問題ありません)。構成サーバーをスケールアップして高可用性を実現するには、サーバーのすべてのインスタンスが同じリポジトリを指すようにする必要があります。これにより、共有ファイルシステムのみが機能します。その場合でも、共有ファイルシステムリポジトリに ssh: プロトコルを使用することをお勧めします。これにより、サーバーはそれを複製し、ローカルの作業コピーをキャッシュとして使用できます。

このリポジトリ実装は、HTTP リソースの {label} パラメーターを git ラベル(コミット ID、ブランチ名、タグ)にマップします。git ブランチまたはタグ名にスラッシュ(/)が含まれている場合は、代わりに HTTP URL のラベルを特別な文字列 (_) で指定する必要があります(他の URL パスとのあいまいさを避けるため)。例: ラベルが foo/bar の場合、スラッシュを置き換えると、次のラベルになります: foo(_)bar。特別な文字列 (_) を含めることは、{application} パラメーターにも適用できます。curl などのコマンドラインクライアントを使用する場合は、URL の括弧に注意してください。シェルから一重引用符('')でエスケープする必要があります。

SSL 証明書の検証をスキップする

構成サーバーによる Git サーバーの SSL 証明書の検証は、git.skipSslValidation プロパティを true (デフォルトは false)に設定することで無効にできます。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://example.com/my/repo
          skipSslValidation: true
HTTP 接続タイムアウトの設定

構成サーバーが HTTP 接続を取得するまで待機する時間を秒単位で構成できます。git.timeout プロパティを使用します (デフォルトは 5)。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://example.com/my/repo
          timeout: 4
GitURI のプレースホルダー

Spring Cloud Config サーバーは、{application} および {profile} (および必要に応じて {label} ですが、ラベルは git ラベルとして適用されることに注意してください)のプレースホルダーを持つ git リポジトリ URL をサポートします。次のような構造を使用して、「アプリケーションごとに 1 つのリポジトリ」ポリシーをサポートできます。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/myorg/{application}

同様のパターンを使用して、{profile} を使用して、「プロファイルごとに 1 つのリポジトリ」ポリシーをサポートすることもできます。

さらに、次の例に示すように、{application} パラメーター内で特別な文字列 "(_)" を使用すると、複数の組織のサポートを有効にできます。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/{application}

ここで、{application} は、リクエスト時に次の形式で提供されます: organization(_)application

パターンマッチングと複数のリポジトリ

Spring Cloud Config には、アプリケーションとプロファイル名のパターンマッチングを使用した、より複雑な要件のサポートも含まれています。パターン形式は、次の例に示すように、ワイルドカードを使用した {application}/{profile} 名のコンマ区切りリストです(ワイルドカードで始まるパターンは引用符で囲む必要がある場合があることに注意してください)。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          repos:
            simple: https://github.com/simple/config-repo
            special:
              pattern: special*/dev*,*special*/dev*
              uri: https://github.com/special/config-repo
            local:
              pattern: local*
              uri: file:/home/configsvc/config-repo

{application}/{profile} がどのパターンとも一致しない場合、spring.cloud.config.server.git.uri で定義されているデフォルトの URI を使用します。上記の例では、「単純な」リポジトリの場合、パターンは simple/* です(すべてのプロファイルで simple という名前の 1 つのアプリケーションにのみ一致します)。「ローカル」リポジトリは、すべてのプロファイルで local で始まるすべてのアプリケーション名と一致します(/* サフィックスは、プロファイルマッチャーがないパターンに自動的に追加されます)。

「単純な」例で使用されている「ワンライナー」ショートカットは、設定するプロパティが URI のみである場合にのみ使用できます。他の何か(資格情報、パターンなど)を設定する必要がある場合は、完全なフォームを使用する必要があります。

リポジトリの pattern プロパティは実際には配列であるため、YAML 配列(またはプロパティファイルの [0][1] などのサフィックス)を使用して複数のパターンにバインドできます。次の例に示すように、複数のプロファイルを使用してアプリを実行する場合は、これを行う必要がある場合があります。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          repos:
            development:
              pattern:
                - '*/development'
                - '*/staging'
              uri: https://github.com/development/config-repo
            staging:
              pattern:
                - '*/qa'
                - '*/production'
              uri: https://github.com/staging/config-repo
Spring Cloud は、* で終わらないプロファイルを含むパターンは、このパターンで始まるプロファイルのリストと実際に一致させたいことを意味すると推測します(したがって、*/staging は ["*/staging", "*/staging,*"] のショートカットなどです)。これは、たとえば、「開発」プロファイルでアプリケーションをローカルで実行する必要がある場合や、「クラウド」プロファイルでリモートで実行する必要がある場合によく見られます。

すべてのリポジトリは、オプションで構成ファイルをサブディレクトリに保存することもでき、それらのディレクトリを検索するパターンは search-paths として指定できます。次の例は、最上位の構成ファイルを示しています。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          search-paths:
            - foo
            - bar*

前の例では、サーバーはトップレベルと foo/ サブディレクトリ、および名前が bar で始まるサブディレクトリで構成ファイルを検索します。

デフォルトでは、サーバーは、構成が最初にリクエストされたときにリモートリポジトリのクローンを作成します。次のトップレベルの例に示すように、起動時にリポジトリのクローンを作成するようにサーバーを構成できます。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://git/common/config-repo.git
          repos:
            team-a:
                pattern: team-a-*
                cloneOnStart: true
                uri: https://git/team-a/config-repo.git
            team-b:
                pattern: team-b-*
                cloneOnStart: false
                uri: https://git/team-b/config-repo.git
            team-c:
                pattern: team-c-*
                uri: https://git/team-a/config-repo.git

前の例では、サーバーは、リクエストを受け入れる前に、起動時に team-a の config-repo のクローンを作成します。他のすべてのリポジトリは、リポジトリからの構成がリクエストされるまで複製されません。

構成サーバーの起動時にクローンを作成するようにリポジトリを設定すると、構成サーバーの起動中に、誤って構成された構成ソース(無効なリポジトリ URI など)をすばやく特定できます。構成ソースに対して cloneOnStart が有効になっていない場合、構成サーバーは、構成が誤っているか無効な構成ソースで正常に起動し、アプリケーションがその構成ソースから構成をリクエストするまでエラーを検出しない場合があります。
認証

リモートリポジトリで HTTP 基本認証を使用するには、次の例に示すように、username プロパティと password プロパティを別々に(URL ではなく)追加します。

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          username: trolley
          password: strongpassword

HTTPS とユーザー資格情報を使用しない場合、デフォルトのディレクトリ(~/.ssh)にキーを格納し、URI が [email protected] (英語) :configuration/cloud-configuration などの SSH の場所を指すときに、SSH もすぐに機能するはずです。Git サーバーのエントリが ~/.ssh/known_hosts ファイルに存在し、ssh-rsa 形式であることが重要です。他の形式(ecdsa-sha2-nistp256 など)はサポートされていません。予期しない事態を避けるために、Git サーバーの known_hosts ファイルにエントリが 1 つだけ存在し、それが構成サーバーに指定した URL と一致することを確認する必要があります。URL でホスト名を使用する場合は、known_hosts ファイルに(IP ではなく)正確にホスト名を含める必要があります。リポジトリには JGit を使用してアクセスするため、そこにあるドキュメントはすべて適用可能です。HTTPS プロキシ設定は、~/.git/config で設定するか、(他の JVM プロセスの場合と同じように)システムプロパティ(-Dhttps.proxyHost および -Dhttps.proxyPort)で設定できます。

~/.git ディレクトリがどこにあるかわからない場合は、git config --global を使用して設定を操作します(たとえば、git config --global http.sslVerify false)。

JGit には、PEM 形式の RSA キーが必要です。以下は、corect 形式でキーを生成する ssh-keygen(openssh から)コマンドの例です。

ssh-keygen -m PEM -t rsa -b 4096 -f ~/config_server_deploy_key.rsa

警告: SSH キーを使用する場合、予想される ssh 秘密鍵は -----BEGIN RSA PRIVATE KEY----- で始まる必要があります。キーが -----BEGIN OPENSSH PRIVATE KEY----- で始まる場合、spring-cloud-config サーバーの起動時に RSA キーはロードされません。エラーは次のようになります。

- Error in object 'spring.cloud.config.server.git': codes [PrivateKeyIsValid.spring.cloud.config.server.git,PrivateKeyIsValid]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [spring.cloud.config.server.git.,]; arguments []; default message []]; default message [Property 'spring.cloud.config.server.git.privateKey' is not a valid private key]

上記のエラーを修正するには、RSA キーを PEM 形式に変換する必要があります。適切な形式で新しいキーを生成するために、openssh を使用した例を上に示します。

AWS CodeCommit による認証

Spring Cloud Config サーバーは AWS CodeCommit [Amazon] 認証もサポートしています。AWS CodeCommit は、コマンドラインから Git を使用するときに認証ヘルパーを使用します。このヘルパーは JGit ライブラリでは使用されないため、GitURI が AWS CodeCommit パターンと一致する場合、AWSCodeCommit 用の JGit CredentialProvider が作成されます。AWS CodeCommit URI は次のパターンに従います。

https://git-codecommit.${AWS_REGION}.amazonaws.com/v1/repos/${repo}

AWS CodeCommit URI でユーザー名とパスワードを指定する場合、リポジトリへのアクセスを提供する AWS accessKeyId および secretAccessKey [Amazon] である必要があります。ユーザー名とパスワードを指定しない場合は、デフォルトのクレデンシャルプロバイダーチェーン [Amazon] を使用して accessKeyId と secretAccessKey が取得されます。

GitURI が CodeCommit URI パターン(前に表示)と一致する場合は、ユーザー名とパスワード、またはデフォルトの認証情報プロバイダーチェーンでサポートされている場所の 1 つで有効な AWS 認証情報を提供する必要があります。AWSEC2 インスタンスは EC2 インスタンスの IAM ロール [Amazon] を使用できます。

software.amazon.awssdk:auth jar はオプションの依存関係です。software.amazon.awssdk:auth jar がクラスパスにない場合、git サーバーの URI に関係なく、AWS CodeCommit 認証情報プロバイダーは作成されません。
Google クラウドソースによる認証

Spring Cloud Config サーバーは、Google クラウドソース リポジトリに対する認証もサポートしています。

Git URI が http または https プロトコルを使用し、ドメイン名が source.developers.google.com の場合は、Google クラウドソース資格情報プロバイダーが使用されます。Google クラウドソースリポジトリ URI の形式は https://source.developers.google.com/p/${GCP_PROJECT}/r/${REPO} (英語) です。リポジトリの URI を取得するには、Google クラウドソース UI で クローンをクリックし、手動で生成された資格情報 を選択します。資格情報は生成せず、表示された URI をコピーするだけです。

Google クラウドソース認証情報プロバイダーは、Google クラウドプラットフォームアプリケーションのデフォルト認証情報を使用します。システムのアプリケーションのデフォルト資格情報を作成する方法については、Google クラウド SDK ドキュメント を参照してください。このアプローチは、開発環境のユーザーアカウントと運用環境のサービスアカウントで機能します。

com.google.auth:google-auth-library-oauth2-http はオプションの依存関係です。google-auth-library-oauth2-http jar がクラスパス上にない場合、git サーバー URI に関係なく、Google クラウドソース資格情報プロバイダーは作成されません。
プロパティを使用した GitSSH 構成

デフォルトでは、Spring Cloud Config サーバーが使用する JGit ライブラリは、SSH URI を使用して Git リポジトリに接続するときに、~/.ssh/known_hosts や /etc/ssh/ssh_config などの SSH 構成ファイルを使用します。Cloud Foundry などのクラウド環境では、ローカルファイルシステムが一時的であるか、簡単にアクセスできない場合があります。このような場合、SSH 構成は Java プロパティを使用して設定できます。プロパティベースの SSH 構成をアクティブ化するには、次の例に示すように、spring.cloud.config.server.git.ignoreLocalSshSettings プロパティを true に設定する必要があります。

  spring:
    cloud:
      config:
        server:
          git:
            uri: [email protected] (英語)  :team/repo1.git
            ignoreLocalSshSettings: true
            hostKey: someHostKey
            hostKeyAlgorithm: ssh-rsa
            privateKey: |
                         -----BEGIN RSA PRIVATE KEY-----
                         MIIEpgIBAAKCAQEAx4UbaDzY5xjW6hc9jwN0mX33XpTDVW9WqHp5AKaRbtAC3DqX
                         IXFMPgw3K45jxRb93f8tv9vL3rD9CUG1Gv4FM+o7ds7FRES5RTjv2RT/JVNJCoqF
                         ol8+ngLqRZCyBtQN7zYByWMRirPGoDUqdPYrj2yq+ObBBNhg5N+hOwKjjpzdj2Ud
                         1l7R+wxIqmJo1IYyy16xS8WsjyQuyC0lL456qkd5BDZ0Ag8j2X9H9D5220Ln7s9i
                         oezTipXipS7p7Jekf3Ywx6abJwOmB0rX79dV4qiNcGgzATnG1PkXxqt76VhcGa0W
                         DDVHEEYGbSQ6hIGSh0I7BQun0aLRZojfE3gqHQIDAQABAoIBAQCZmGrk8BK6tXCd
                         fY6yTiKxFzwb38IQP0ojIUWNrq0+9Xt+NsypviLHkXfXXCKKU4zUHeIGVRq5MN9b
                         BO56/RrcQHHOoJdUWuOV2qMqJvPUtC0CpGkD+valhfD75MxoXU7s3FK7yjxy3rsG
                         EmfA6tHV8/4a5umo5TqSd2YTm5B19AhRqiuUVI1wTB41DjULUGiMYrnYrhzQlVvj
                         5MjnKTlYu3V8PoYDfv1GmxPPh6vlpafXEeEYN8VB97e5x3DGHjZ5UrurAmTLTdO8
                         +AahyoKsIY612TkkQthJlt7FJAwnCGMgY6podzzvzICLFmmTXYiZ/28I4BX/mOSe
                         pZVnfRixAoGBAO6Uiwt40/PKs53mCEWngslSCsh9oGAaLTf/XdvMns5VmuyyAyKG
                         ti8Ol5wqBMi4GIUzjbgUvSUt+IowIrG3f5tN85wpjQ1UGVcpTnl5Qo9xaS1PFScQ
                         xrtWZ9eNj2TsIAMp/svJsyGG3OibxfnuAIpSXNQiJPwRlW3irzpGgVx/AoGBANYW
                         dnhshUcEHMJi3aXwR12OTDnaLoanVGLwLnkqLSYUZA7ZegpKq90UAuBdcEfgdpyi
                         PhKpeaeIiAaNnFo8m9aoTKr+7I6/uMTlwrVnfrsVTZv3orxjwQV20YIBCVRKD1uX
                         VhE0ozPZxwwKSPAFocpyWpGHGreGF1AIYBE9UBtjAoGBAI8bfPgJpyFyMiGBjO6z
                         FwlJc/xlFqDusrcHL7abW5qq0L4v3R+FrJw3ZYufzLTVcKfdj6GelwJJO+8wBm+R
                         gTKYJItEhT48duLIfTDyIpHGVm9+I1MGhh5zKuCqIhxIYr9jHloBB7kRm0rPvYY4
                         VAykcNgyDvtAVODP+4m6JvhjAoGBALbtTqErKN47V0+JJpapLnF0KxGrqeGIjIRV
                         cYA6V4WYGr7NeIfesecfOC356PyhgPfpcVyEztwlvwTKb3RzIT1TZN8fH4YBr6Ee
                         KTbTjefRFhVUjQqnucAvfGi29f+9oE3Ei9f7wA+H35ocF6JvTYUsHNMIO/3gZ38N
                         CPjyCMa9AoGBAMhsITNe3QcbsXAbdUR00dDsIFVROzyFJ2m40i4KCRM35bC/BIBs
                         q0TY3we+ERB40U8Z2BvU61QuwaunJ2+uGadHo58VSVdggqAo0BSkH58innKKt96J
                         69pcVH/4rmLbXdcmNYGm6iu+MlPQk4BUZknHSmVHIFdJ0EPupVaQ8RHT
                         -----END RSA PRIVATE KEY-----

次の表に、SSH 構成プロパティを示します。

表 1: SSH 構成プロパティ
プロパティ名 コメント

ignoreLocalSshSettings

true の場合、ファイルベースの SSH 構成ではなくプロパティベースを使用します。リポジトリ定義内ではなく、spring.cloud.config.server.git.ignoreLocalSshSettings として設定する必要があります。

privateKey

有効な SSH 秘密鍵。ignoreLocalSshSettings が true で、GitURI が SSH 形式の場合に設定する必要があります。

hostKey

有効な SSH ホストキー。hostKeyAlgorithm も設定されている場合は、設定する必要があります。

hostKeyAlgorithm

ssh-dss, ssh-rsa, ssh-ed25519, ecdsa-sha2-nistp256, ecdsa-sha2-nistp384, or ecdsa-sha2-nistp521 の 1 つ。hostKey も設定されている場合は、設定する必要があります。

strictHostKeyChecking

true or false. If false, ignore errors with host key.

knownHostsFile

Location of custom .known_hosts file.

preferredAuthentications

Override server authentication method order. This should allow for evading login prompts if server has keyboard-interactive authentication before the publickey method.

Placeholders in Git Search Paths

Spring Cloud Config Server also supports a search path with placeholders for the {application} and {profile} (and {label} if you need it), as shown in the following example:

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          search-paths: '{application}'

The preceding listing causes a search of the repository for files in the same name as the directory (as well as the top level). Wildcards are also valid in a search path with placeholders (any matching directory is included in the search).

Force pull in Git Repositories

As mentioned earlier, Spring Cloud Config Server makes a clone of the remote git repository in case the local copy gets dirty (for example, folder content changes by an OS process) such that Spring Cloud Config Server cannot update the local copy from remote repository.

To solve this issue, there is a force-pull property that makes Spring Cloud Config Server force pull from the remote repository if the local copy is dirty, as shown in the following example:

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          force-pull: true

If you have a multiple-repositories configuration, you can configure the force-pull property per repository, as shown in the following example:

spring:
  cloud:
    config:
      server:
        git:
          uri: https://git/common/config-repo.git
          force-pull: true
          repos:
            team-a:
                pattern: team-a-*
                uri: https://git/team-a/config-repo.git
                force-pull: true
            team-b:
                pattern: team-b-*
                uri: https://git/team-b/config-repo.git
                force-pull: true
            team-c:
                pattern: team-c-*
                uri: https://git/team-a/config-repo.git
The default value for force-pull property is false.
Deleting untracked branches in Git Repositories

As Spring Cloud Config Server has a clone of the remote git repository after check-outing branch to local repo (e.g fetching properties by label) it will keep this branch forever or till the next server restart (which creates new local repo). So there could be a case when remote branch is deleted but local copy of it is still available for fetching. And if Spring Cloud Config Server client service starts with --spring.cloud.config.label=deletedRemoteBranch,master it will fetch properties from deletedRemoteBranch local branch, but not from master.

In order to keep local repository branches clean and up to remote - deleteUntrackedBranches property could be set. It will make Spring Cloud Config Server force delete untracked branches from local repository. Example:

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          deleteUntrackedBranches: true
The default value for deleteUntrackedBranches property is false.
Git Refresh Rate

You can control how often the config server will fetch updated configuration data from your Git backend by using spring.cloud.config.server.git.refreshRate. The value of this property is specified in seconds. By default the value is 0, meaning the config server will fetch updated configuration from the Git repo every time it is requested.

Default Label

The default label used for Git is main. If you do not set spring.cloud.config.server.git.defaultLabel and a branch named main does not exist, the config server will by default also try to checkout a branch named master. If you would like to disable to the fallback branch behavior you can set spring.cloud.config.server.git.tryMasterBranch to false.

Version Control Backend Filesystem Use

With VCS-based backends (git, svn), files are checked out or cloned to the local filesystem. By default, they are put in the system temporary directory with a prefix of config-repo-. On linux, for example, it could be /tmp/config-repo-<randomid>. Some operating systems routinely clean out (英語) temporary directories. This can lead to unexpected behavior, such as missing properties. To avoid this problem, change the directory that Config Server uses by setting spring.cloud.config.server.git.basedir or spring.cloud.config.server.svn.basedir to a directory that does not reside in the system temp structure.

File System Backend

There is also a “native” profile in the Config Server that does not use Git but loads the config files from the local classpath or file system (any static URL you want to point to with spring.cloud.config.server.native.searchLocations). To use the native profile, launch the Config Server with spring.profiles.active=native.

Remember to use the file: prefix for file resources (the default without a prefix is usually the classpath). As with any Spring Boot configuration, you can embed ${}-style environment placeholders, but remember that absolute paths in Windows require an extra / (for example, file:///${user.home}/config-repo).
The default value of the searchLocations is identical to a local Spring Boot application (that is, [classpath:/, classpath:/config, file:./, file:./config]). This does not expose the application.properties from the server to all clients, because any property sources present in the server are removed before being sent to the client.
A filesystem backend is great for getting started quickly and for testing. To use it in production, you need to be sure that the file system is reliable and shared across all instances of the Config Server.

The search locations can contain placeholders for {application}, {profile}, and {label}. In this way, you can segregate the directories in the path and choose a strategy that makes sense for you (such as subdirectory per application or subdirectory per profile).

If you do not use placeholders in the search locations, this repository also appends the {label} parameter of the HTTP resource to a suffix on the search path, so properties files are loaded from each search location and a subdirectory with the same name as the label (the labelled properties take precedence in the Spring Environment). Thus, the default behaviour with no placeholders is the same as adding a search location ending with /{label}/. For example, file:/tmp/config is the same as file:/tmp/config,file:/tmp/config/{label}. This behavior can be disabled by setting spring.cloud.config.server.native.addLabelLocations=false.

Vault Backend

Spring Cloud Config Server also supports Vault (英語) as a backend.

Vault is a tool for securely accessing secrets. A secret is anything that to which you want to tightly control access, such as API keys, passwords, certificates, and other sensitive information. Vault provides a unified interface to any secret while providing tight access control and recording a detailed audit log.

For more information on Vault, see the Vault quick start guide (英語) .

To enable the config server to use a Vault backend, you can run your config server with the vault profile. For example, in your config server’s application.properties, you can add spring.profiles.active=vault.

By default, Spring Cloud Config Server uses Token based Authentication to fetch config from Vault. Vault also supports additional authentication methods like AppRole, LDAP, JWT, CloudFoundry, Kubernetes Auth. In order to use any authentication method other than TOKEN or the X-Config-Token header, we need to have Spring Vault Core on the classpath so that Config Server can delegate authentication to that library. Please add the below dependencies to your Config Server App.

Maven (pom.xml)

<dependencies>
	<dependency>
		<groupId>org.springframework.vault</groupId>
		<artifactId>spring-vault-core</artifactId>
	</dependency>
</dependencies>

Gradle (build.gradle)

dependencies {
    implementation "org.springframework.vault:spring-vault-core"
}

デフォルトでは、構成サーバーは Vault サーバーが http://127.0.0.1:8200 (英語) で実行されていることを前提としています。また、バックエンドの名前が secret であり、キーが application であると想定しています。これらのデフォルトはすべて、構成サーバーの application.properties で構成できます。次の表に、構成可能な Vault プロパティを示します。

名前 デフォルト値

host

127.0.0.1

port

8200

scheme

http

backend

秘密

defaultKey

アプリケーション

profileSeparator

,

kvVersion

1

skipSslValidation

false

timeout

5

namespace

null

上記の表のすべてのプロパティには、接頭辞 spring.cloud.config.server.vault を付けるか、複合構成の正しい Vault セクションに配置する必要があります。

構成可能なすべてのプロパティは、org.springframework.cloud.config.server.environment.VaultEnvironmentProperties にあります。

Vault 0.10.0 は、以前のバージョンとは異なる API を公開するバージョン管理された Key-Value バックエンド(k/v バックエンドバージョン 2)を導入しました。現在、マウントパスと実際のコンテキストパスの間に data/ が必要であり、秘密を data オブジェクトにラップしています。spring.cloud.config.server.vault.kv-version=2 を設定すると、これが考慮されます。

オプションで、Vault Enterprise X-Vault-Namespace ヘッダーのサポートがあります。Vault に送信するには、namespace プロパティを設定します。

構成サーバーが実行されている状態で、サーバーに HTTP リクエストを送信して、Vault バックエンドから値を取得できます。そのためには、Vault サーバーのトークンが必要です。

まず、次の例に示すように、Vault にいくつかのデータを配置します。

$ vault kv put secret/application foo=bar baz=bam
$ vault kv put secret/myapp foo=myappsbar

次に、次の例に示すように、構成サーバーに HTTP リクエストを送信して、値を取得します。

$ curl -X "GET" "http://localhost:8888/myapp/default" -H "X-Config-Token: yourtoken"

次のようなレスポンスが表示されます。

{
   "name":"myapp",
   "profiles":[
      "default"
   ],
   "label":null,
   "version":null,
   "state":null,
   "propertySources":[
      {
         "name":"vault:myapp",
         "source":{
            "foo":"myappsbar"
         }
      },
      {
         "name":"vault:application",
         "source":{
            "baz":"bam",
            "foo":"bar"
         }
      }
   ]
}

クライアントが ConfigServer に Vault と通信させるために必要な認証を提供するデフォルトの方法は、X-Config-Token ヘッダーを設定することです。ただし、Spring Cloud Vault と同じ構成プロパティを設定することにより、代わりにヘッダーを省略してサーバーで認証を構成できます。設定するプロパティは spring.cloud.config.server.vault.authentication です。サポートされている認証方法の 1 つに設定する必要があります。spring.cloud.vault についてドキュメント化されているものと同じプロパティ名を使用し、代わりに spring.cloud.config.server.vault プレフィックスを使用して、使用する認証方法に固有の他のプロパティを設定する必要がある場合もあります。詳細については、Spring Cloud Vault リファレンスガイド (英語) を参照してください。

X-Config-Token ヘッダーを省略し、server プロパティを使用して認証を設定する場合、構成サーバーアプリケーションは、追加の認証オプションを有効にするために Spring Vault への追加の依存関係を必要とします。その依存関係を追加する方法については、Spring Vault リファレンスガイドを参照してください。
複数のプロパティソース

Vault を使用する場合、アプリケーションに複数のプロパティソースを提供できます。例: Vault の次のパスにデータを書き込んだと仮定します。

secret/myApp,dev
secret/myApp
secret/application,dev
secret/application

secret/application に書き込まれたプロパティは、ConfigServer を使用するすべてのアプリケーションで使用できます。myApp という名前のアプリケーションでは、secret/myApp および secret/application に書き込まれたすべてのプロパティを使用できます。myApp で dev プロファイルが有効になっている場合、上記のすべてのパスに書き込まれたプロパティが使用可能になり、リストの最初のパスのプロパティが他のパスよりも優先されます。

プロキシを介したバックエンドへのアクセス

構成サーバーは、HTTP または HTTPS プロキシを介して Git または Vault バックエンドにアクセスできます。この動作は、proxy.http および proxy.https の設定によって、Git または Vault のいずれかで制御されます。これらの設定はリポジトリごとであるため、コンポジット環境リポジトリを使用している場合は、コンポジット内の各バックエンドのプロキシ設定を個別に構成する必要があります。HTTP URL と HTTP SURL に別々のプロキシサーバーを必要とするネットワークを使用している場合は、単一のバックエンドに対して HTTP プロキシ設定と HTTPS プロキシ設定の両方を構成できます。この場合、http アクセスは http プロキシを使用し、https は https プロキシにアクセスします。また、アプリケーションとプロキシの間でプロキシ定義プロトコルを使用して、両方のプロトコルに使用される 1 つのプロキシを指定することもできます。

次の表に、HTTP プロキシと HTTPS プロキシの両方のプロキシ構成プロパティを示します。これらのプロパティはすべて、接頭辞 proxy.http または proxy.https を付ける必要があります。

表 2: プロキシ構成のプロパティ
プロパティ名 コメント

host

プロキシのホスト。

ポート

プロキシにアクセスするためのポート。

nonProxyHosts

構成サーバーがプロキシの外部でアクセスする必要があるすべてのホスト。proxy.http.nonProxyHosts と proxy.https.nonProxyHosts の両方に値が指定されている場合は、proxy.http 値が使用されます。

username

プロキシへの認証に使用するユーザー名。proxy.http.username と proxy.https.username の両方に値が指定されている場合は、proxy.http 値が使用されます。

パスワード

プロキシへの認証に使用するパスワード。proxy.http.password と proxy.https.password の両方に値が指定されている場合は、proxy.http 値が使用されます。

次の構成では、HTTPS プロキシを使用して Git リポジトリにアクセスします。

spring:
  profiles:
    active: git
  cloud:
    config:
      server:
        git:
          uri: https://github.com/spring-cloud-samples/config-repo
          proxy:
            https:
              host: my-proxy.host.io
              password: myproxypassword
              port: '3128'
              username: myproxyusername
              nonProxyHosts: example.com

すべてのアプリケーションと構成を共有する

次のトピックで説明するように、すべてのアプリケーション間で構成を共有することは、採用するアプローチによって異なります。

ファイルベースのリポジトリ

ファイルベース(git、svn、native)リポジトリでは、application* (application.propertiesapplication.ymlapplication-*.properties など)のファイル名を持つリソースがすべてのクライアントアプリケーション間で共有されます。これらのファイル名のリソースを使用してグローバルデフォルトを構成し、必要に応じてアプリケーション固有のファイルでオーバーライドすることができます。

プロパティオーバーライド機能は、グローバルデフォルトの設定にも使用でき、プレースホルダーアプリケーションでローカルにオーバーライドできます。

「ネイティブ」プロファイル(ローカルファイルシステムバックエンド)では、サーバー自体の構成の一部ではない明示的な検索場所を使用する必要があります。それ以外の場合、デフォルトの検索場所にある application* リソースは、サーバーの一部であるため削除されます。
Vault サーバー

Vault をバックエンドとして使用する場合、構成を secret/application に配置することにより、すべてのアプリケーションと構成を共有できます。例: 次の Vault コマンドを実行すると、構成サーバーを使用するすべてのアプリケーションで、プロパティ foo および baz を使用できるようになります。

$ vault write secret/application foo=bar baz=bam
CredHub サーバー

CredHub をバックエンドとして使用する場合、構成を /application/ に配置するか、アプリケーションの default プロファイルに配置することにより、すべてのアプリケーションと構成を共有できます。例: 次の CredHub コマンドを実行すると、構成サーバーを使用するすべてのアプリケーションで、プロパティ shared.color1 および shared.color2 を使用できるようになります。

credhub set --name "/application/profile/master/shared" --type=json
value: {"shared.color1": "blue", "shared.color": "red"}
credhub set --name "/my-app/default/master/more-shared" --type=json
value: {"shared.word1": "hello", "shared.word2": "world"}

AWS シークレットマネージャー

AWS Secrets Manager をバックエンドとして使用する場合、構成を /application/ に配置するか、アプリケーションの default プロファイルに配置することで、すべてのアプリケーションと構成を共有できます。例: 次のキーを使用してシークレットを追加すると、構成サーバーを使用するすべてのアプリケーションで、プロパティ shared.foo および shared.bar を使用できるようになります。

secret name = /secret/application-default/
secret value =
{
 shared.foo: foo,
 shared.bar: bar
}

または

secret name = /secret/application/
secret value =
{
 shared.foo: foo,
 shared.bar: bar
}
ラベル付きバージョン

AWS Secrets Manager リポジトリでは、Git バックエンドと同じように、設定環境のラベル付きバージョンを保持できます。

リポジトリの実装は、HTTP リソースの {label} パラメーターを AWS Secrets Manager シークレットのステージングラベル [Amazon] にマップします。ラベル付きシークレットを作成するには、シークレットを作成するか、その内容を更新して、ステージングラベルを定義します (AWS ドキュメントではバージョンステージと呼ばれることがあります)。例:

$ aws secretsmanager create-secret \
      --name /secret/test/ \
      --secret-string '{"version":"1"}'
{
    "ARN": "arn:aws:secretsmanager:us-east-1:123456789012:secret:/secret/test/-a1b2c3",
    "Name": "/secret/test/",
    "VersionId": "cd291674-de2f-41de-8f3b-37dbf4880d69"
}

$ aws secretsmanager update-secret-version-stage \
      --secret-id /secret/test/ \
      --version-stage 1.0.0 \
      --move-to-version-id cd291674-de2f-41de-8f3b-37dbf4880d69

{
    "ARN": "arn:aws:secretsmanager:us-east-1:123456789012:secret:/secret/test/-a1b2c3",
    "Name": "/secret/test/",
}

デフォルトのラベルを設定するには、spring.cloud.config.server.aws-secretsmanager.default-label プロパティを使用します。プロパティが定義されていない場合、バックエンドは AWSCURRENT をステージングラベルとして使用します。

spring:
  profiles:
    active: aws-secretsmanager
  cloud:
    config:
      server:
        aws-secretsmanager:
          region: us-east-1
          default-label: 1.0.0

デフォルトのラベルが設定されておらず、リクエストでラベルが定義されていない場合、リポジトリは、ラベル付きバージョンのサポートが無効になっているかのようにシークレットを使用することに注意してください。また、デフォルトのラベルは、ラベル付きサポートが有効になっている場合にのみ使用されます。そうでなければ、このプロパティを定義しても意味がありません。

ステージングラベルにスラッシュ (/) が含まれている場合、HTTP URL のラベルは代わりに特別な文字列 (_) で指定する必要があることに注意してください (他の URL パスとのあいまいさを避けるため) Git バックエンドのセクションが説明するのと同じ方法です。

spring.cloud.config.server.aws-secretsmanager.ignore-label プロパティを使用して、HTTP リソースの {label} パラメーターおよび spring.cloud.config.server.aws-secretsmanager.default-label プロパティを無視します。リポジトリは、ラベル付きバージョンのサポートが無効になっているかのようにシークレットを使用します。

spring:
  profiles:
    active: aws-secretsmanager
  cloud:
    config:
      server:
        aws-secretsmanager:
          region: us-east-1
          ignore-label: true

AWS パラメーターストア

AWS パラメーターストアをバックエンドとして使用する場合、プロパティを /application 階層内に配置することで、すべてのアプリケーションと設定を共有できます。

例: 次の名前のパラメーターを追加すると、構成サーバーを使用するすべてのアプリケーションで、プロパティ foo.bar および fred.baz を使用できるようになります。

/config/application/foo.bar
/config/application-default/fred.baz

JDBC バックエンド

Spring Cloud Config サーバーは、構成プロパティのバックエンドとして JDBC(リレーショナルデータベース)をサポートします。この機能を有効にするには、クラスパスに spring-boot-starter-data-jdbc を追加して jdbc プロファイルを使用するか、型 JdbcEnvironmentRepository の Bean を追加します。クラスパスに適切な依存関係を含めると(詳細についてはユーザーガイドを参照)、Spring Boot はデータソースを構成します。

spring.cloud.config.server.jdbc.enabled プロパティを false に設定することにより、JdbcEnvironmentRepository の自動構成を無効にできます。

データベースには、APPLICATIONPROFILELABEL (通常の Environment の意味)と呼ばれる列を持つ PROPERTIES と呼ばれるテーブルに加えて、Properties スタイルのキーと値のペア用の KEY と VALUE が必要です。すべてのフィールドは Java では String 型であるため、必要な長さの VARCHAR にすることができます。プロパティ値は、{application}-{profile}.properties という名前の Spring Boot プロパティファイルから取得した場合と同じように動作します。これには、後処理ステップとして適用される(つまり、リポジトリの実装に直接適用されない)すべての暗号化と復号化が含まれます。

JDBC に使用されるデフォルトのラベルは master です。spring.cloud.config.server.jdbc.defaultLabel を設定することで変更できます。

Redis バックエンド

Spring Cloud Config サーバーは、構成プロパティのバックエンドとして Redis をサポートします。Spring Data Redis に依存関係を追加することで、この機能を有効にできます。

pom.xml
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
</dependencies>

次の構成では、Spring Data RedisTemplate を使用して Redis にアクセスします。spring.redis.* プロパティを使用して、デフォルトの接続設定を上書きできます。

spring:
  profiles:
    active: redis
  redis:
    host: redis
    port: 16379

プロパティは、ハッシュのフィールドとして保存する必要があります。ハッシュの名前は、spring.application.name プロパティ、または spring.application.name と spring.profiles.active[n] の接続詞と同じである必要があります。

HMSET sample-app server.port "8100" sample.topic.name "test" test.property1 "property1"

ハッシュの上に表示されているコマンドを実行した後、値を持つ次のキーが含まれている必要があります。

HGETALL sample-app
{
  "server.port": "8100",
  "sample.topic.name": "test",
  "test.property1": "property1"
}
プロファイルが指定されていない場合、default が使用されます。

AWSS3 バックエンド

Spring Cloud Config サーバーは、構成プロパティのバックエンドとして AWSS3 をサポートします。Amazon S3 用の AWSJava SDK に依存関係を追加することで、この機能を有効にできます。

pom.xml
<dependencies>
	<dependency>
		<groupId>software.amazon.awssdk</groupId>
		<artifactId>s3</artifactId>
	</dependency>
</dependencies>

次の設定では、AWSS3 クライアントを使用して設定ファイルにアクセスします。spring.cloud.config.server.awss3.* プロパティを使用して、構成が保存されているバケットを選択できます。

spring:
  profiles:
    active: awss3
  cloud:
    config:
      server:
        awss3:
          region: us-east-1
          bucket: bucket1

AWS URL を指定して、S3 サービスの標準エンドポイントを spring.cloud.config.server.awss3.endpoint でオーバーライド [Amazon] することもできます。これにより、S3 のベータリージョンおよびその他の S3 互換ストレージ API のサポートが可能になります。

資格情報はデフォルトのクレデンシャルプロバイダーチェーン [Amazon] を使用して検出されます。バージョン管理および暗号化されたバケットは、追加の構成なしでサポートされます。

構成ファイルは、{application}-{profile}.properties{application}-{profile}.yml{application}-{profile}.json としてバケットに保存されます。オプションのラベルを指定して、ファイルへのディレクトリパスを指定できます。

プロファイルが指定されていない場合、default が使用されます。

AWS パラメーターストアバックエンド

Spring Cloud Config サーバーは、設定プロパティのバックエンドとして AWS パラメーターストアをサポートしています。この機能を有効にするには、AWS Java SDK for SSM [Amazon] に依存関係を追加します。

pom.xml
<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>ssm</artifactId>
</dependency>

次の設定では、AWSSSM クライアントを使用してパラメーターにアクセスします。

spring:
  profiles:
    active: awsparamstore
  cloud:
    config:
      server:
        awsparamstore:
          region: eu-west-2
          endpoint: https://ssm.eu-west-2.amazonaws.com
          origin: aws:parameter:
          prefix: /config/service
          profile-separator: _
          recursive: true
          decrypt-values: true
          max-results: 5

次の表で、AWS パラメーターストアの設定プロパティについて説明します。

表 3: AWS パラメーターストアの設定プロパティ
プロパティ名 必須 デフォルト値 コメント

領域

いいえ

AWS パラメーターストアクライアントが使用するリージョン。明示的に設定されていない場合、SDK はデフォルトのリージョンプロバイダーチェーン [Amazon] を使用して使用するリージョンを決定しようとします。

終点

いいえ

AWSSSM クライアントのエントリポイントの URL。これを使用して、API リクエストの代替エンドポイントを指定できます。

origin

いいえ

aws:ssm:parameter:

出所を示すためにプロパティソースの名前に追加されるプレフィックス。

prefix

いいえ

/config

AWS パラメーターストアからロードされたすべてのプロパティのパラメーター階層の L1 レベルを示すプレフィックス。

profile-separator

いいえ

-

追加されたプロファイルをコンテキスト名から分離する文字列。

再帰

いいえ

true

階層内のすべての AWS パラメーターの取得を示すフラグ。

decrypt-values

いいえ

true

値が復号化されたすべての AWS パラメーターの取得を示すフラグ。

max-results

いいえ

10

AWS Parameter StoreAPI 呼び出しで返されるアイテムの最大数。

AWS パラメーターストア API クレデンシャルは、デフォルトのクレデンシャルプロバイダーチェーン [Amazon] を使用して決定されます。バージョン管理されたパラメーターは、最新バージョンを返すデフォルトの動作ですでにサポートされています。

  • アプリケーションが指定されていない場合は application がデフォルトであり、プロファイルが指定されていない場合は default が使用されます。

  • awsparamstore.prefix の有効な値は、スラッシュで始まり、その後に 1 つ以上の有効なパスセグメントが続くか、空である必要があります。

  • awsparamstore.profile-separator の有効な値には、ドット、ダッシュ、アンダースコアのみを含めることができます。

  • awsparamstore.max-results の有効な値は、[1、10] の範囲内である必要があります。

AWS SecretsManager バックエンド

Spring Cloud Config サーバーは、構成プロパティのバックエンドとして AWS シークレットマネージャー [Amazon] をサポートします。シークレットマネージャー用の AWSJava SDK [Amazon] に依存関係を追加することで、この機能を有効にできます。

pom.xml
<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>secretsmanager</artifactId>
</dependency>

次の設定では、AWS SecretsManager クライアントを使用してシークレットにアクセスします。

spring:
  profiles:
  	active: awssecretsmanager
  cloud:
    config:
      server:
        aws-secretsmanager:
          region: us-east-1
          endpoint: https://us-east-1.console.aws.amazon.com/
          origin: aws:secrets:
          prefix: /secret/foo
          profileSeparator: _

AWS Secrets Manager API クレデンシャルは、デフォルトのクレデンシャルプロバイダーチェーン [Amazon] を使用して決定されます。

  • アプリケーションが指定されていない場合は application がデフォルトであり、プロファイルが指定されていない場合は default が使用されます。

  • ignoreLabel が true に設定されている場合、label プロパティと defaultLabel プロパティは両方とも無視されます。

CredHub バックエンド

Spring Cloud Config サーバーは、構成プロパティのバックエンドとして CredHub (英語) をサポートします。Spring CredHub に依存関係を追加することで、この機能を有効にできます。

pom.xml
<dependencies>
	<dependency>
		<groupId>org.springframework.credhub</groupId>
		<artifactId>spring-credhub-starter</artifactId>
	</dependency>
</dependencies>

次の構成では、相互 TLS を使用して CredHub にアクセスします。

spring:
  profiles:
    active: credhub
  cloud:
    config:
      server:
        credhub:
          url: https://credhub:8844

プロパティは、次のように JSON として保存する必要があります。

credhub set --name "/demo-app/default/master/toggles" --type=json
value: {"toggle.button": "blue", "toggle.link": "red"}
credhub set --name "/demo-app/default/master/abs" --type=json
value: {"marketing.enabled": true, "external.enabled": false}

spring.cloud.config.name=demo-app という名前のすべてのクライアントアプリケーションには、次のプロパティがあります。

{
    toggle.button: "blue",
    toggle.link: "red",
    marketing.enabled: true,
    external.enabled: false
}
プロファイルが指定されていない場合は default が使用され、ラベルが指定されていない場合は master がデフォルト値として使用されます。注: application に追加された値は、すべてのアプリケーションで共有されます。
OAuth 2.0

UAA (英語) をプロバイダーとして使用して、OAuth 2.0 (英語) で認証できます。

pom.xml
<dependencies>
	<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-config</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-oauth2-client</artifactId>
	</dependency>
</dependencies>

次の構成では、OAuth 2.0 と UAA を使用して CredHub にアクセスします。

spring:
  profiles:
    active: credhub
  cloud:
    config:
      server:
        credhub:
          url: https://credhub:8844
          oauth2:
            registration-id: credhub-client
  security:
    oauth2:
      client:
        registration:
          credhub-client:
            provider: uaa
            client-id: credhub_config_server
            client-secret: asecret
            authorization-grant-type: client_credentials
        provider:
          uaa:
            token-uri: https://uaa:8443/oauth/token
使用される UAA クライアント ID には、スコープとして credhub.read が必要です。

複合環境リポジトリ

シナリオによっては、複数の環境リポジトリから構成データをプルしたい場合があります。これを行うには、構成サーバーのアプリケーションプロパティまたは YAML ファイルで composite プロファイルを有効にします。たとえば、Subversion リポジトリと 2 つの Git リポジトリから構成データをプルする場合は、構成サーバーに次のプロパティを設定できます。

spring:
  profiles:
    active: composite
  cloud:
    config:
      server:
        composite:
        -
          type: svn
          uri: file:///path/to/svn/repo
        -
          type: git
          uri: file:///path/to/rex/git/repo
        -
          type: git
          uri: file:///path/to/walter/git/repo

この構成を使用すると、優先順位は、リポジトリが composite キーにリストされている順序によって決定されます。上記の例では、Subversion リポジトリが最初にリストされているため、Subversion リポジトリで見つかった値は、Git リポジトリの 1 つで同じプロパティで見つかった値を上書きします。rex Git リポジトリで見つかった値は、walter Git リポジトリで同じプロパティで見つかった値の前に使用されます。

それぞれ異なる型のリポジトリからのみ構成データをプルする場合は、構成サーバーのアプリケーションプロパティまたは YAML ファイルで、composite プロファイルではなく、対応するプロファイルを有効にできます。たとえば、単一の Git リポジトリと単一の HashiCorp Vault サーバーから構成データをプルする場合は、構成サーバーに次のプロパティを設定できます。

spring:
  profiles:
    active: git, vault
  cloud:
    config:
      server:
        git:
          uri: file:///path/to/git/repo
          order: 2
        vault:
          host: 127.0.0.1
          port: 8200
          order: 1

この構成を使用すると、order プロパティによって優先順位を決定できます。order プロパティを使用して、すべてのリポジトリの優先順位を指定できます。order プロパティの数値が小さいほど、優先度が高くなります。リポジトリの優先順位は、同じプロパティの値を含むリポジトリ間の潜在的な競合を解決できます。

前の例のように、複合環境に Vault サーバーが含まれている場合は、構成サーバーに対して行われるすべてのリクエストに Vault トークンを含める必要があります。Vault バックエンドを参照してください。
環境リポジトリから値を取得するときに何らかの型の障害が発生すると、複合環境全体で障害が発生します。リポジトリに障害が発生した場合でもコンポジットを続行する場合は、spring.cloud.config.server.failOnCompositeError を false に設定できます。
複合環境を使用する場合、すべてのリポジトリに同じラベルが含まれていることが重要です。前の例と同様の環境があり、master ラベルを使用して構成データをリクエストしたが、Subversion リポジトリに master と呼ばれるブランチが含まれていない場合、リクエスト全体が失敗します。
カスタム複合環境リポジトリ

Spring Cloud の環境リポジトリの 1 つを使用することに加えて、複合環境の一部として含まれる独自の EnvironmentRepository Bean を提供することもできます。そのためには、Bean が EnvironmentRepository インターフェースを実装する必要があります。複合環境内でカスタム EnvironmentRepository の優先度を制御する場合は、Ordered インターフェースも実装し、getOrdered メソッドをオーバーライドする必要があります。Ordered インターフェースを実装しない場合、EnvironmentRepository には最低の優先順位が与えられます。

プロパティの上書き

構成サーバーには、オペレーターがすべてのアプリケーションに構成プロパティを提供できるようにする「オーバーライド」機能があります。オーバーライドされたプロパティは、通常の Spring Boot フックを使用するアプリケーションによって誤って変更されることはありません。オーバーライドを宣言するには、次の例に示すように、名前と値のペアのマップを spring.cloud.config.server.overrides に追加します。

spring:
  cloud:
    config:
      server:
        overrides:
          foo: bar

上記の例では、構成クライアントであるすべてのアプリケーションが、独自の構成に関係なく foo=bar を読み取ります。

構成システムは、アプリケーションに特定の方法で構成データを使用させることはできません。オーバーライドは強制できません。ただし、Spring Cloud Config クライアントに役立つデフォルトの動作を提供します。
通常、${} を使用する Spring 環境プレースホルダーは、円記号(\)を使用して $ または { をエスケープすることにより、エスケープ(およびクライアントで解決)できます。例: アプリが独自の app.foo を提供しない限り、\${app.foo:bar} は bar に解決されます。
YAML では、円記号自体をエスケープする必要はありません。ただし、プロパティファイルでは、サーバーでオーバーライドを構成するときに円記号をエスケープする必要があります。

リモートリポジトリで spring.cloud.config.overrideNone=true フラグ(デフォルトは false)を設定することにより、クライアントのすべてのオーバーライドの優先度をデフォルト値のように変更して、アプリケーションが環境変数またはシステムプロパティに独自の値を提供できるようにすることができます。

Bootstrap を使用してプロパティをオーバーライドする

config first bootstrap を有効にすると、構成で使用される外部環境リポジトリ (Git、Vault、SVN など) に常駐するアプリケーションの構成内に 2 つのプロパティを配置することで、構成サーバーからの構成をクライアント設定でオーバーライドできるようになります。サーバー。

spring.cloud.config.allowOverride=true
spring.cloud.config.overrideNone=true

Bootstrap を有効にし、これら 2 つのプロパティを true に設定すると、クライアントアプリケーション構成内の構成サーバーから構成をオーバーライドできます。

プレースホルダーを使用したプロパティのオーバーライド

config first ブートストラップを有効にせずにプロパティをオーバーライドするよりクリーンな方法は、構成サーバーからの構成でプロパティプレースホルダーを使用することです。

たとえば、構成サーバーからの構成に次のプロパティが含まれている場合

hello=${app.hello:Hello From Config Server!}

ローカルアプリケーション構成で app.hello を設定することにより、構成サーバーからの hello の値をオーバーライドできます。

app.hello=Hello From Application!

プロファイルを使用したプロパティのオーバーライド

構成サーバーからのプロパティをオーバーライドする最後の方法は、クライアントアプリケーション内のプロファイル固有の構成ファイルで指定することです。

例: 構成サーバーから次の構成がある場合

hello="Hello From Config Server!"

プロファイル固有の構成ファイルで hello を設定し、そのプロファイルを有効にすることにより、クライアントアプリケーションで hello の値をオーバーライドできます。

application-overrides.properties
hello="Hello From Application!"

上記の例では、overrides プロファイルを有効にする必要があります。

ヘルス指標

構成サーバーには、構成された EnvironmentRepository が機能しているかどうかを確認するヘルスインジケーターが付属しています。デフォルトでは、app という名前のアプリケーション、default プロファイル、EnvironmentRepository 実装によって提供されるデフォルトのラベルを EnvironmentRepository に要求します。

次の例に示すように、カスタムプロファイルおよびカスタムラベルとともにより多くのアプリケーションをチェックするようにヘルスインジケーターを構成できます。

spring:
  cloud:
    config:
      server:
        health:
          repositories:
            myservice:
              label: mylabel
            myservice-dev:
              name: myservice
              profiles: development

management.health.config.enabled=false を設定すると、ヘルスインジケーターを無効にできます。

また、プロパティ spring.cloud.config.server.health.down-health-status を設定することにより、独自のカスタム down ステータスを提供できます (デフォルトでは "DOWN' に値が設定されます)。

セキュリティ

Spring Security と Spring Boot は多くのセキュリティ構成をサポートしているため、(物理ネットワークセキュリティから OAuth2 ベアラートークンまで)自分にとって意味のある方法で ConfigServer を保護できます。

デフォルトの SpringBoot 構成 HTTP 基本セキュリティを使用するには、クラスパスに Spring Security を含めます(たとえば、spring-boot-starter-security を介して)。デフォルトは、user のユーザー名とランダムに生成されたパスワードです。ランダムパスワードは実際には役に立たないため、(spring.security.user.password を設定して)パスワードを構成し、暗号化することをお勧めします(その方法については以下を参照してください)。

アクチュエーターとセキュリティ

一部のプラットフォームは、ヘルスチェックなどを構成し、/actuator/health または他のアクチュエーターエンドポイントを指します。アクチュエーターが構成サーバーの依存関係ではない場合、/actuator/ へのリクエストは構成サーバー API /{application}/{label} と一致し、安全な情報をリークする可能性があります。この場合、spring-boot-starter-actuator 依存関係を追加し、/actuator/ を呼び出すユーザーが /{application}/{label} の構成サーバー API にアクセスできないようにユーザーを構成することを忘れないでください。

暗号化と復号化

暗号化および復号化機能を使用するには、JVM にフルストレングスの JCE がインストールされている必要があります(デフォルトでは含まれていません)。Oracle から「JavaCryptographyExtension(JCE)Unlimited Strength Jurisdiction Policy Files」をダウンロードし、インストール手順に従うことができます(基本的に、JRE lib/security ディレクトリ内の 2 つのポリシーファイルをダウンロードしたものに置き換える必要があります)。

リモートプロパティソースに暗号化されたコンテンツ({cipher} で始まる値)が含まれている場合、HTTP 経由でクライアントに送信する前に復号化されます。この設定の主な利点は、プロパティ値が「静止」しているとき(たとえば、git リポジトリ内)にプレーンテキストである必要がないことです。値を復号化できない場合は、プロパティソースから削除され、同じキーが接頭辞として invalid と「該当なし」を意味する値(通常は <n/a>)が付いた追加のプロパティが追加されます。これは主に、暗号文がパスワードとして使用され、誤って漏洩するのを防ぐためです。

構成クライアントアプリケーション用にリモート構成リポジトリをセットアップする場合、次のような application.yml が含まれている可能性があります。

application.yml
spring:
  datasource:
    username: dbuser
    password: '{cipher}FKSAJDFGYOS8F7GLHAKERGFHLSAJ'

application.properties ファイルの暗号化された値は、引用符で囲むことはできません。それ以外の場合、値は復号化されません。次の例は、機能する値を示しています。

application.properties
spring.datasource.username: dbuser
spring.datasource.password: {cipher}FKSAJDFGYOS8F7GLHAKERGFHLSAJ

このプレーンテキストを共有 git リポジトリに安全にプッシュでき、シークレットパスワードは保護されたままになります。

サーバーは、/encrypt および /decrypt エンドポイントも公開します(これらが保護されており、認可されたエージェントによってのみアクセスされることを前提としています)。リモート構成ファイルを編集する場合、次の例に示すように、構成サーバーを使用して、/encrypt エンドポイントに POST することで値を暗号化できます。

$ curl localhost:8888/encrypt -s -d mysecret
682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
curl でテストしている場合は、(-d の代わりに) --data-urlencode を使用し、値のプレフィックスを付けて = で暗号化するか(curl ではこれが必要)、明示的な Content-Type: text/plain を設定して、特殊文字('+')がある場合に curl がデータを正しくエンコードするようにします。特に注意が必要です)。
暗号化された値に curl コマンド統計を含めないように注意してください。これが、例で -s オプションを使用して無音にする理由です。値をファイルに出力すると、この問題を回避できます。

次の例に示すように、逆の操作は /decrypt を介して利用することもできます(サーバーが対称鍵または完全鍵ペアで構成されている場合)。

$ curl localhost:8888/decrypt -s -d 682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
mysecret

暗号化された値を取得し、{cipher} プレフィックスを追加してから、YAML またはプロパティファイルに配置し、コミットしてリモート(安全でない可能性がある)ストアにプッシュします。

/encrypt エンドポイントと /decrypt エンドポイントはどちらも、/*/{application}/{profiles} の形式のパスを受け入れます。これを使用して、クライアントがメイン環境リソースを呼び出すときに、アプリケーションごと(名前)ごとおよびプロファイルごとに暗号化を制御できます。

このきめ細かい方法で暗号化を制御するには、名前とプロファイルごとに異なる暗号化機能を作成する型 TextEncryptorLocator の @Bean も提供する必要があります。デフォルトで提供されているものはそうしません(すべての暗号化は同じキーを使用します)。

次の例に示すように、spring コマンドラインクライアント(Spring Cloud CLI 拡張機能がインストールされている)を使用して、暗号化と復号化を行うこともできます。

$ spring encrypt mysecret --key foo
682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
$ spring decrypt --key foo 682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
mysecret

次の例に示すように、ファイル内のキー(暗号化用の RSA 公開鍵など)を使用するには、キー値の前に "@" を付け、ファイルパスを指定します。

$ spring encrypt mysecret --key @${HOME}/.ssh/id_rsa.pub
AQAjPgt3eFZQXwt8tsHAVv/QHiY5sI2dRcR+...
--key 引数は必須です(-- プレフィックスがあるにもかかわらず)。

鍵管理

構成サーバーは、対称(共有)キーまたは非対称キー(RSA キーペア)を使用できます。非対称の選択はセキュリティの点で優れていますが、application.properties で構成する単一のプロパティ値であるため、対称キーを使用する方が便利な場合がよくあります。

対称鍵を構成するには、encrypt.key を秘密文字列に設定する必要があります(または、ENCRYPT_KEY 環境変数を使用してプレーンテキスト構成ファイルに入れないようにします)。

クラスパスに spring-cloud-starter-bootstrap を含めるか、システムプロパティとして spring.cloud.bootstrap.enabled=true を設定する場合は、bootstrap.properties で encrypt.key を設定する必要があります。
encrypt.key を使用して非対称キーを構成することはできません。

非対称キーを構成するには、キーストアを使用します(たとえば、JDK に付属の keytool ユーティリティによって作成されたもの)。キーストアのプロパティは encrypt.keyStore.* であり、* は次のようになります。

プロパティ 説明

encrypt.keyStore.location

Resource の場所が含まれています

encrypt.keyStore.password

キーストアのロックを解除するパスワードを保持します

encrypt.keyStore.alias

ストア内で使用するキーを識別します

encrypt.keyStore.type

作成する KeyStore の型。デフォルトは jks です。

暗号化は公開鍵を使用して行われ、復号化には秘密鍵が必要です。原則として、暗号化のみを行う場合(および秘密鍵を使用してローカルで値を復号化する準備ができている場合)は、サーバーで公開鍵のみを構成できます。実際には、ローカルで復号化を実行したくない場合があります。これは、キー管理プロセスをサーバーに集中させるのではなく、すべてのクライアントに分散させるためです。一方、構成サーバーが比較的安全でなく、暗号化されたプロパティを必要とするクライアントがほんの一握りである場合は、便利なオプションになる可能性があります。

テスト用のキーストアの作成

テスト用のキーストアを作成するには、次のようなコマンドを使用できます。

$ keytool -genkeypair -alias mytestkey -keyalg RSA \
  -dname "CN=Web Server,OU=Unit,O=Organization,L=City,S=State,C=US" \
  -keypass changeme -keystore server.jks -storepass letmein
JDK 11 以降を使用している場合、上記のコマンドを使用すると、次の警告が表示される場合があります。この場合、おそらく keypass と storepass の値が一致していることを確認する必要があります。
Warning:  Different store and key passwords not supported for PKCS12 KeyStores. Ignoring user-specified -keypass value.

server.jks ファイルをクラスパス(たとえば)に配置してから、bootstrap.yml で、構成サーバー用に次の設定を作成します。

encrypt:
  keyStore:
    location: classpath:/server.jks
    password: letmein
    alias: mytestkey
    secret: changeme

複数のキーとキーローテーションの使用

暗号化されたプロパティ値の {cipher} プレフィックスに加えて、構成サーバーは、(Base64 でエンコードされた)暗号文の開始前に 0 個以上の {name:value} プレフィックスを検索します。キーは TextEncryptorLocator に渡され、TextEncryptorLocator は、暗号の TextEncryptor を見つけるために必要なロジックを実行できます。キーストア(encrypt.keystore.location)を構成した場合、デフォルトのロケーターは、key プレフィックスによって提供されるエイリアスを持ち、次のような暗号文を持つキーを探します。

foo:
  bar: `{cipher}{key:testkey}...`

ロケーターは "testkey" という名前のキーを探します。シークレットは、プレフィックスに {secret:…​} 値を使用して提供することもできます。ただし、指定されていない場合、デフォルトではキーストアパスワードが使用されます(これは、キーストアを構築し、シークレットを指定しないときに取得するものです)。シークレットを提供する場合は、カスタム SecretLocator を使用してシークレットも暗号化する必要があります。

キーが数バイトの構成データの暗号化にのみ使用されている場合(つまり、他の場所では使用されていない場合)、暗号化の理由でキーのローテーションはほとんど必要ありません。ただし、場合によってはキーを変更する必要があります(たとえば、セキュリティ違反が発生した場合)。その場合、すべてのクライアントはソース構成ファイルを変更し(たとえば、git で)、すべての暗号で新しい {key:…​} プレフィックスを使用する必要があります。クライアントは、最初にキーエイリアスが ConfigServer キーストアで使用可能であることを確認する必要があることに注意してください。

構成サーバーにすべての暗号化と復号化を処理させたい場合は、{name:value} プレフィックスを /encrypt エンドポイントに送信されるプレーンテキストとして追加することもできます。

暗号化されたプロパティの提供

サーバーで構成を行うのではなく、クライアントに構成をローカルで復号化させたい場合があります。その場合、キーを見つけるために encrypt.* 構成を提供すると、/encrypt エンドポイントと /decrypt エンドポイントを引き続き使用できますが、spring.cloud.config.server.encrypt.enabled=false を bootstrap.[yml|properties] に配置して、発信プロパティの復号化を明示的にオフにする必要があります。エンドポイントを気にしない場合は、キーまたは有効フラグのいずれも構成していなくても機能するはずです。

代替フォーマットの提供

環境エンドポイントのデフォルトの JSON 形式は、Environment 抽象化に直接マップされるため、Spring アプリケーションでの使用に最適です。必要に応じて、リソースパスにサフィックス(".yml"、".yaml"、または ".properties" )を追加することで、YAML または Java プロパティと同じデータを使用できます。これは、JSON エンドポイントの構造やそれらが提供する追加のメタデータを気にしないアプリケーションによる消費に役立ちます(たとえば、Spring を使用しないアプリケーションは、このアプローチの単純さから恩恵を受ける可能性があります)。

YAML およびプロパティ表現には追加のフラグ(resolvePlaceholders と呼ばれるブールクエリパラメーターとして提供)があり、可能な場合は、レンダリング前にソースドキュメント(標準の Spring ${…​} 形式)のプレースホルダーを解決する必要があることを通知します。これは、Spring プレースホルダーの規則について知らないコンシューマーにとって便利な機能です。

YAML またはプロパティ形式の使用には、主にメタデータの損失に関連して制限があります。例: JSON は、プロパティソースの順序付きリストとして構造化されており、名前はソースに関連付けられています。値の元に複数のソースがあり、元のソースファイルの名前が失われている場合でも、YAML フォームとプロパティフォームは 1 つのマップに統合されます。また、YAML 表現は、必ずしもバッキングリポジトリ内の YAML ソースの忠実な表現であるとは限りません。これはフラットなプロパティソースのリストから構築されており、キーの形式について想定する必要があります。

プレーンテキストの提供

Environment 抽象化(または YAML またはプロパティ形式での Environment 抽象化の代替表現の 1 つ)を使用する代わりに、アプリケーションには、環境に合わせた汎用のプレーンテキスト構成ファイルが必要になる場合があります。構成サーバーは、/{application}/{profile}/{label}/{path} の追加エンドポイントを介してこれらを提供します。applicationprofilelabel は通常の環境エンドポイントと同じ意味ですが、path はファイル名(log.xml など)へのパスです。このエンドポイントのソースファイルは、環境エンドポイントの場合と同じ方法で配置されます。プロパティと YAML ファイルに同じ検索パスが使用されます。ただし、一致するすべてのリソースを集約する代わりに、最初に一致したリソースのみが返されます。

リソースが検索された後、通常の形式(${…​})のプレースホルダーは、指定されたアプリケーション名、プロファイル、ラベルに有効な Environment を使用して解決されます。このようにして、リソースエンドポイントは環境エンドポイントと緊密に統合されます。

環境構成のソースファイルと同様に、profile を使用してファイル名を解決します。プロファイル固有のファイルが必要な場合は、/*/development/*/logback.xml を logback-development.xml というファイルで解決できます(logback.xml よりも優先されます)。
label を提供せず、サーバーにデフォルトのラベルを使用させる場合は、useDefaultLabel リクエストパラメーターを提供できます。default プロファイルの前述の例は /sample/default/nginx.conf?useDefaultLabel である可能性があります。

現在、Spring Cloud Config は、git、SVN、ネイティブバックエンド、AWSS3 のプレーンテキストを提供できます。git、SVN、ネイティブバックエンドのサポートは同じです。AWSS3 の動作は少し異なります。次のセクションでは、それぞれがどのように機能するかを示します。

バイナリファイルの提供

構成サーバーからバイナリファイルを提供するには、application/octet-stream の Accept ヘッダーを送信する必要があります。

Git、SVN、ネイティブバックエンド

GIT または SVN リポジトリまたはネイティブバックエンドの次の例を検討してください。

application.yml
nginx.conf

nginx.conf は、次のようになります。

server {
    listen              80;
    server_name         ${nginx.server.name};
}

application.yml は、次のようになります。

nginx:
  server:
    name: example.com
---
spring:
  profiles: development
nginx:
  server:
    name: develop.com

/sample/default/master/nginx.conf リソースは次のようになります。

server {
    listen              80;
    server_name         example.com;
}

/sample/development/master/nginx.conf は次のようになります。

server {
    listen              80;
    server_name         develop.com;
}

AWS S3

AWS s3 のプレーンテキストの提供を有効にするには、構成サーバーアプリケーションに io.awspring.cloud:spring-cloud-aws-context への依存関係を含める必要があります。その依存関係を設定する方法の詳細については、Spring Cloud AWS リファレンスガイドを参照してください。さらに、Spring Cloud AWS を Spring Boot と共に使用する場合、自動構成の依存関係を含めると便利です。次に、Spring Cloud AWS リファレンスガイドに従って、Spring Cloud AWS を構成する必要があります。

プレーンテキストの復号化

デフォルトでは、プレーンテキストファイルの暗号化された値は復号化されません。プレーンテキストファイルの復号化を有効にするには、bootstrap.[yml|properties] で spring.cloud.config.server.encrypt.enabled=true と spring.cloud.config.server.encrypt.plainTextEncrypt=true を設定します

プレーンテキストファイルの復号化は、YAML、JSON、プロパティファイル拡張子でのみサポートされています。

この機能が有効になっていて、サポートされていないファイル拡張子がリクエストされた場合、ファイル内の暗号化された値は復号化されません。

構成サーバーの埋め込み

構成サーバーは、スタンドアロンアプリケーションとして最適に実行されます。ただし、必要に応じて、別のアプリケーションに埋め込むことができます。これを行うには、@EnableConfigServer アノテーションを使用します。この場合、spring.cloud.config.server.bootstrap という名前のオプションのプロパティが役立ちます。これは、サーバーが独自のリモートリポジトリから自身を構成する必要があるかどうかを示すフラグです。デフォルトでは、起動が遅れる可能性があるため、フラグはオフになっています。ただし、別のアプリケーションに組み込む場合は、他のアプリケーションと同じ方法で初期化するのが理にかなっています。spring.cloud.config.server.bootstrap を true に設定する場合は、複合環境リポジトリ構成も使用する必要があります。たとえば

spring:
  application:
    name: configserver
  profiles:
    active: composite
  cloud:
    config:
      server:
        composite:
          - type: native
            search-locations: ${HOME}/Desktop/config
        bootstrap: true
ブートストラップフラグを使用する場合、構成サーバーの名前とリポジトリ URI を bootstrap.yml で構成する必要があります。

サーバーエンドポイントの場所を変更するには、(オプションで) spring.cloud.config.server.prefix (たとえば、/config)を設定して、プレフィックスでリソースを提供できます。プレフィックスは / で開始する必要がありますが、終了することはできません。これは、構成サーバーの @RequestMappings に適用されます(つまり、Spring Boot server.servletPath および server.contextPath プレフィックスの下)。

アプリケーションの構成を(構成サーバーからではなく)バックエンドリポジトリから直接読み取りたい場合は、基本的に、エンドポイントのない組み込み構成サーバーが必要です。@EnableConfigServer アノテーションを使用しないことでエンドポイントを完全にオフにすることができます(spring.cloud.config.server.bootstrap=true を設定)。

プッシュ通知と Spring Cloud Bus

多くのソースコードリポジトリプロバイダー(Github、Gitlab、Gitea、Gitee、Gogs、Bitbucket など)は、Webhook を介してリポジトリの変更を通知します。プロバイダーのユーザーインターフェースを介して、関心のある URL および一連のイベントとして Webhook を構成できます。たとえば、Github (英語) は、コミットのリストと push に設定されたヘッダー(X-Github-Event)を含む JSON 本文を使用して Webhook への POST を使用します。spring-cloud-config-monitor ライブラリへの依存関係を追加し、構成サーバーで Spring Cloud Bus をアクティブ化すると、/monitor エンドポイントが有効になります。

Webhook がアクティブ化されると、構成サーバーは、変更された可能性があると思われるアプリケーションを対象とした RefreshRemoteApplicationEvent を送信します。変更の検出は戦略化できます。ただし、デフォルトでは、アプリケーション名に一致するファイルの変更を検索します(たとえば、foo.properties は foo アプリケーションを対象とし、application.properties はすべてのアプリケーションを対象とします)。動作をオーバーライドする場合に使用する戦略は PropertyPathNotificationExtractor です。これは、リクエストヘッダーと本文をパラメーターとして受け入れ、変更されたファイルパスのリストを返します。

デフォルトの構成は、Github、Gitlab、Gitea、Gitee、Gogs、Bitbucket でそのまま使用できます。Github、Gitlab、Gitee、Bitbucket からの JSON 通知に加えて、path={application} のパターンでフォームにエンコードされた本文パラメーターを使用して /monitor に POST することにより、変更通知をトリガーできます。そうすることで、{application} パターン(ワイルドカードを含めることができる)に一致するアプリケーションにブロードキャストします。

RefreshRemoteApplicationEvent は、構成サーバーとクライアントアプリケーションの両方で spring-cloud-bus がアクティブ化されている場合にのみ送信されます。
デフォルト設定では、ローカル git リポジトリのファイルシステムの変更も検出されます。その場合、Webhook は使用されません。ただし、構成ファイルを編集するとすぐに、リフレッシュがブロードキャストされます。

AOT およびネイティブイメージのサポート

4.0.0 以降、Spring Cloud Config サーバーは Spring AOT 変換をサポートします。ただし、当面の間、GraalVM ネイティブイメージはサポートされていません。ネイティブイメージサポートの実装は graal#5134 [GitHub] (英語) によってブロックされており、おそらく修正するには https://github.com/graalvm/taming-build-time-initialization (英語) の作業を完了する必要があります。

Spring Cloud Config クライアント

Spring Boot アプリケーションは、Spring Config Server(またはアプリケーション開発者が提供するその他の外部プロパティソース)をすぐに利用できます。また、Environment 変更イベントに関連するいくつかの追加の便利な機能を取り上げます。

Spring Boot 構成データのインポート

Spring Boot 2.4 は、spring.config.import プロパティを介して構成データをインポートする新しい方法を導入しました。これが、ConfigServer にバインドするデフォルトの方法になりました。

オプションで構成サーバーに接続するには、application.properties で以下を設定します。

application.properties
spring.config.import=optional:configserver:

これにより、デフォルトの "http://localhost:8888" の場所にある構成サーバーに接続されます。optional: プレフィックスを削除すると、構成サーバーに接続できない場合、構成クライアントが失敗します。構成サーバーの場所を変更するには、spring.cloud.config.uri を設定するか、spring.config.import=optional:configserver:http://myhost:8888 などの spring.config.import ステートメントに URL を追加します。import プロパティの場所は、uri プロパティよりも優先されます。

Spring Boot Config Data は、2 段階のプロセスで構成を解決します。まず、default プロファイルを使用してすべての構成をロードします。これにより、Spring Boot は追加のプロファイルをアクティブ化する可能性のあるすべての構成を収集できるようになります。アクティブ化されたプロファイルをすべて収集した後、アクティブなプロファイルの追加構成をロードします。このため、設定を取得するために Spring Cloud Config サーバーに対して複数のリクエストが行われる場合があります。これは正常であり、spring.config.import の使用時に Spring Boot が構成をロードする方法の副作用です。Spring Cloud Config の以前のバージョンでは、リクエストは 1 つだけ行われていましたが、これは、構成サーバーからの構成からプロファイルをアクティブ化できないことを意味していました。「デフォルト」プロファイルのみを使用した追加リクエストにより、これが可能になります。

spring.config.import を介してインポートする Spring Boot Config Data メソッドには、bootstrap ファイル(プロパティまたは yaml)は必要ありません。

最初のブートストラップを構成する

構成サーバーに接続する従来のブートストラップ方法を使用するには、プロパティまたは spring-cloud-starter-bootstrap スターターを介してブートストラップを有効にする必要があります。プロパティは spring.cloud.bootstrap.enabled=true です。システムプロパティまたは環境変数として設定する必要があります。ブートストラップが有効になると、クラスパスに Spring Cloud Config クライアントがあるアプリケーションは、次のように構成サーバーに接続します。構成クライアントが起動すると、構成サーバーにバインドし(spring.cloud.config.uri ブートストラップ構成プロパティを介して)、リモートプロパティソースを使用して Spring Environment を初期化します。

この動作の最終的な結果として、構成サーバーを使用するすべてのクライアントアプリケーションには、サーバーアドレスが spring.cloud.config.uri (デフォルトは "http://localhost:8888")に設定された bootstrap.yml (または環境変数)が必要です。

最初のルックアップ検出

config first bootstrap を使用している場合を除き、構成プロパティに optional: プレフィックスが付いた spring.config.import プロパティが必要です。例: spring.config.import=optional:configserver:

Spring Cloud Netflix および Eureka サービス検出または Spring Cloud Consul などの DiscoveryClient 実装を使用する場合、構成サーバーを検出サービスに登録できます。

DiscoveryClient を使用して構成サーバーを検索する場合は、spring.cloud.config.discovery.enabled=true を設定することで実行できます (デフォルトは false です)。例: Spring Cloud Netflix では、Eureka サーバーアドレスを定義する必要があります (たとえば、eureka.client.serviceUrl.defaultZone で)。このオプションを使用するための価格は、サービス登録を見つけるための、起動時の追加のネットワークラウンドトリップです。利点は、Discovery Service が固定ポイントである限り、構成サーバーがその座標を変更できることです。デフォルトのサービス ID は configserver ですが、クライアントでは spring.cloud.config.discovery.serviceId を設定することで (およびサーバーでは spring.application.name を設定するなどのサービスの通常の方法で) 変更できます。

検出クライアントの実装はすべて、ある種のメタデータマップをサポートしています(たとえば、Eureka 用の eureka.instance.metadataMap があります)。クライアントが正しく接続できるように、構成サーバーのいくつかの追加プロパティをサービス登録メタデータで構成する必要がある場合があります。構成サーバーが HTTPBasic で保護されている場合は、資格情報を user および password として構成できます。また、構成サーバーにコンテキストパスがある場合は、configPath を設定できます。例: 次の YAML ファイルは、Eureka クライアントである構成サーバー用です。

eureka:
  instance:
    ...
    metadataMap:
      user: osufhalskjrtl
      password: lviuhlszvaorhvlo5847
      configPath: /config

Eureka および WebClient を使用した最初のブートストラップの検出

Spring Cloud Netflix の Eureka DiscoveryClient を使用していて、Jersey または RestTemplate の代わりに WebClient も使用したい場合は、クラスパスに WebClient を組み込み、eureka.client.webclient.enabled=true を設定する必要があります。

クライアントのフェイルファスト設定

場合によっては、サービスが構成サーバーに接続できない場合、サービスの起動に失敗することがあります。これが望ましい動作である場合は、ブートストラップ構成プロパティ spring.cloud.config.fail-fast=true を設定して、クライアントを例外で停止させます。

spring.config.import を使用して同様の機能を取得するには、optional: プレフィックスを省略します。

クライアントの再試行設定

アプリケーションの起動時に構成サーバーが時々利用不能になることが予想される場合は、失敗後も構成サーバーを試行し続けるようにすることができます。まず、spring.cloud.config.fail-fast=true を設定する必要があります。次に、spring-retry と spring-boot-starter-aop をクラスパスに追加する必要があります。デフォルトの動作では、初期バックオフ間隔 1000 ミリ秒と後続のバックオフの指数乗数 1.1 で 6 回再試行します。spring.cloud.config.retry.* 構成プロパティを設定することで、これらのプロパティ (およびその他) を構成できます。ランダム指数バックオフポリシーを使用するには、spring.cloud.config.retry.useRandomPolicy を true に設定します。

再試行動作を完全に制御し、レガシーブートストラップを使用するには、ID が configServerRetryInterceptor である型 RetryOperationsInterceptor の @Bean を追加します。Spring Retry には、作成をサポートする RetryInterceptorBuilder があります。

spring.config.import を使用したクライアントの再試行設定

再試行は Spring Boot spring.config.import ステートメントで機能し、通常のプロパティが機能します。ただし、import ステートメントが application-prod.properties などのプロファイルにある場合は、再試行を構成する別の方法が必要です。構成は、インポートステートメントの URL パラメーターとして配置する必要があります。

application-prod.properties
spring.config.import=configserver:http://configserver.example.com?fail-fast=true&max-attempts=10&max-interval=1500&multiplier=1.2&initial-interval=1100"

これにより、spring.cloud.config.fail-fast=true (上記のプレフィックスが欠落していることに注意してください) と、使用可能なすべての spring.cloud.config.retry.* 構成プロパティが設定されます。

リモート構成リソースの検索

Config Service は、/{application}/{profile}/{label} からのプロパティソースを提供します。クライアントアプリのデフォルトのバインディングは次のとおりです。

  • 「アプリ」= ${spring.application.name}

  • 「プロファイル」= ${spring.profiles.active} (実際に Environment.getActiveProfiles())

  • " ラベル "=" マスター "

プロパティ ${spring.application.name} を設定するときは、正しいプロパティソースを解決する際の課題を防ぐために、アプリ名の前に予約語 application- を付けないでください。

spring.cloud.config.* (* は nameprofilelabel)を設定することにより、これらすべてをオーバーライドできます。label は、以前のバージョンの構成にロールバックできます。デフォルトの ConfigServer 実装では、git ラベル、ブランチ名、コミット ID にすることができます。ラベルは、コンマ区切りのリストとして提供することもできます。その場合、リスト内の項目は、成功するまで 1 つずつ試行されます。この動作は、機能ブランチで作業するときに役立ちます。たとえば、構成ラベルをブランチに合わせて、オプションにしたい場合があります(その場合は、spring.cloud.config.label=myfeature,develop を使用します)。

構成サーバーに複数の URL を指定する

構成サーバーの複数のインスタンスがデプロイされていて、1 つ以上のインスタンスが利用できないか、(Git サーバーがダウンしている場合などに) 時々リクエストを受け入れることができないと予想される場合に、高可用性を確保するには、複数の URL を指定することができます ( spring.cloud.config.uri プロパティのコンマ区切りのリスト) またはすべてのインスタンスを Eureka のようなサービスレジストリに登録します (Discovery-First Bootstrap モードを使用している場合)。

spring.cloud.config.uri にリストされている URL は、リストされている順序で試行されます。デフォルトでは、構成クライアントは、高可用性を確保する試みが成功するまで、各 URL からプロパティを取得しようとします。

ただし、構成サーバーが実行されていないとき (つまり、アプリケーションが終了したとき) または接続タイムアウトが発生したときにのみ高可用性を確保したい場合は、spring.cloud.config.multiple-uri-strategy を connection-timeout-only に設定します。( spring.cloud.config.multiple-uri-strategy のデフォルト値は always です) 例: 構成サーバーが 500 (内部的サーバーエラー) レスポンスを返した場合、または構成クライアントが構成サーバーから 401 を受信した場合 (不正な資格情報またはその他の原因による)、構成クライアントは他の URL からプロパティを取得しようとしないでください。400 エラー (場合によっては 404 を除く) は、可用性の課題ではなく、ユーザーの課題を示します。構成サーバーが Git サーバーを使用するように設定されていて、Git サーバーへの呼び出しが失敗した場合、404 エラーが発生する可能性があることに注意してください。

spring.cloud.config.uri ではなく、1 つの spring.config.import キーで複数の場所を指定できます。ロケーションは定義された順序で処理され、後のインポートが優先されます。ただし、spring.cloud.config.fail-fast が true の場合、最初の構成サーバー呼び出しが何らかの理由で失敗すると、構成クライアントは失敗します。fail-fast が false の場合、失敗の理由に関係なく、1 つの呼び出しが成功するまですべての URL を試行します。(spring.config.import で URL を指定する場合、spring.cloud.config.multiple-uri-strategy は適用されません。)

構成サーバーで HTTP 基本セキュリティを使用している場合、現在、spring.cloud.config.uri プロパティで指定した各 URL に資格情報を埋め込んだ場合にのみ、ConfigServer ごとの認証資格情報をサポートできます。他の種類のセキュリティメカニズムを使用している場合、(現在)ConfigServer ごとの認証と認可をサポートすることはできません。

タイムアウトの構成

タイムアウトしきい値を構成する場合:

  • 読み取りタイムアウトは、プロパティ spring.cloud.config.request-read-timeout を使用して構成できます。

  • 接続タイムアウトは、プロパティ spring.cloud.config.request-connect-timeout を使用して構成できます。

セキュリティ

サーバーで HTTP 基本セキュリティを使用する場合、クライアントはパスワード(およびデフォルトでない場合はユーザー名)を知っている必要があります。次の例に示すように、ユーザー名とパスワードは、構成サーバーの URI を介して、または個別のユーザー名とパスワードのプロパティを介して指定できます。

spring:
  cloud:
    config:
     uri: https://user:[email protected] (英語)  

次の例は、同じ情報を渡す別の方法を示しています。

spring:
  cloud:
    config:
     uri: https://myconfig.mycompany.com
     username: user
     password: secret

spring.cloud.config.password および spring.cloud.config.username 値は、URI で提供されるすべてのものをオーバーライドします。

アプリを Cloud Foundry にデプロイする場合、パスワードを提供する最善の方法は、サービス資格情報を使用することです(URI など、構成ファイルに含める必要がないため)。次の例は、ローカルで、configserver という名前の Cloud Foundry 上のユーザー提供サービスに対して機能します。

spring:
  cloud:
    config:
     uri: ${vcap.services.configserver.credentials.uri:http://user:password@localhost:8888}

構成サーバーでクライアント側の TLS 証明書が必要な場合は、次の例に示すように、プロパティを介してクライアント側の TLS 証明書とトラストストアを構成できます。

spring:
  cloud:
    config:
      uri: https://myconfig.myconfig.com
      tls:
        enabled: true
        key-store: <path-of-key-store>
        key-store-type: PKCS12
        key-store-password: <key-store-password>
        key-password: <key-password>
        trust-store: <path-of-trust-store>
        trust-store-type: PKCS12
        trust-store-password: <trust-store-password>

構成クライアント側 TLS を有効にするには、spring.cloud.config.tls.enabled が true である必要があります。spring.cloud.config.tls.trust-store を省略すると、JVM のデフォルトのトラストストアが使用されます。spring.cloud.config.tls.key-store-type および spring.cloud.config.tls.trust-store-type のデフォルト値は PKCS12 です。パスワードのプロパティを省略すると、空のパスワードが想定されます。

別の形式のセキュリティを使用する場合は、RestTemplate を ConfigServicePropertySourceLocator に提供する必要がある場合があります(たとえば、ブートストラップコンテキストでそれを取得して挿入することによって)。

ヘルス指標

構成クライアントは、構成サーバーから構成をロードしようとする Spring Boot ヘルスインジケーターを提供します。ヘルスインジケータは、health.config.enabled=false を設定することで無効にできます。パフォーマンス上の理由から、レスポンスもキャッシュされます。デフォルトのキャッシュ存続時間は 5 分です。その値を変更するには、health.config.time-to-live プロパティ(ミリ秒単位)を設定します。

カスタム RestTemplate の提供

場合によっては、クライアントから構成サーバーに対して行われるリクエストをカスタマイズする必要がある場合があります。通常、これには、リクエストを認証するための特別な Authorization ヘッダーをサーバーに渡すことが含まれます。

構成データを使用したカスタム RestTemplate の提供

構成データの使用時にカスタム RestTemplate を提供するには:

  1. BootstrapRegistryInitializer を実装するクラスを作成する

    CustomBootstrapRegistryInitializer.java
    public class CustomBootstrapRegistryInitializer implements BootstrapRegistryInitializer {
    
    	@Override
    	public void initialize(BootstrapRegistry registry) {
    		registry.register(RestTemplate.class, context -> {
    			RestTemplate restTemplate = new RestTemplate();
    			// Customize RestTemplate here
    			return restTemplate;
    		});
    	}
    
    }
    
  2. 次の例に示すように、resources/META-INF で、spring.factories というファイルを作成し、カスタム構成を指定します。

    spring.factories
    org.springframework.boot.BootstrapRegistryInitializer=com.my.config.client.CustomBootstrapRegistryInitializer
ブートストラップを使用したカスタム RestTemplate の提供

ブートストラップの使用時にカスタム RestTemplate を提供するには:

  1. 次の例に示すように、PropertySourceLocator の実装を使用して新しい構成 Bean を作成します。

    CustomConfigServiceBootstrapConfiguration.java
    @Configuration
    public class CustomConfigServiceBootstrapConfiguration {
        @Bean
        public ConfigServicePropertySourceLocator configServicePropertySourceLocator() {
            ConfigClientProperties clientProperties = configClientProperties();
           ConfigServicePropertySourceLocator configServicePropertySourceLocator =  new ConfigServicePropertySourceLocator(clientProperties);
            configServicePropertySourceLocator.setRestTemplate(customRestTemplate(clientProperties));
            return configServicePropertySourceLocator;
        }
    }
    
    Authorization ヘッダーを追加するための単純化されたアプローチとして、代わりに spring.cloud.config.headers.* プロパティを使用できます。
  2. 次の例に示すように、resources/META-INF で、spring.factories というファイルを作成し、カスタム構成を指定します。

    spring.factories
    org.springframework.cloud.bootstrap.BootstrapConfiguration = com.my.config.client.CustomConfigServiceBootstrapConfiguration

Vault

構成サーバーへのバックエンドとして Vault を使用する場合、クライアントは、サーバーが Vault から値を取得するためのトークンを提供する必要があります。このトークンは、次の例に示すように、bootstrap.yml で spring.cloud.config.token を設定することにより、クライアント内で提供できます。

spring:
  cloud:
    config:
      token: YourVaultToken

Vault のネストされたキー

Vault は、次の例に示すように、Vault に格納されている値にキーをネストする機能をサポートしています。

echo -n '{"appA": {"secret": "appAsecret"}, "bar": "baz"}' | vault write secret/myapp -

このコマンドは、JSON オブジェクトを Vault に書き込みます。Spring でこれらの値にアクセスするには、次の例に示すように、従来の dot(.)アノテーションを使用します。

@Value("${appA.secret}")
String name = "World";

上記のコードは、name 変数の値を appAsecret に設定します。

AOT およびネイティブイメージのサポート

4.0.0 以降、Spring Cloud Config クライアントは Spring AOT 変換と GraalVM ネイティブイメージをサポートします。

AOT およびネイティブイメージのサポートは、config first ブートストラップ spring.config.use-legacy-processing=true を使用) では利用できません。
リフレッシュスコープは、ネイティブイメージではサポートされていません。構成クライアントアプリケーションをネイティブイメージとして実行する場合は、必ず spring.cloud.refresh.enabled プロパティを false に設定してください。
Spring Cloud Config クライアントを含むプロジェクトを構築する場合、接続先の構成データソース (Spring Cloud Config サーバー、Consul、Zookeeper、Vault など) が利用可能であることを確認する必要があります。例: Spring Cloud Config サーバーから構成データを取得する場合は、そのインスタンスが実行中であり、構成クライアントのセットアップで指定されたポートで使用できることを確認してください。これが必要なのは、アプリケーションコンテキストがビルド時に最適化され、ターゲット環境を解決する必要があるためです。
AOT およびネイティブモードでは、ビルド時にコンフィギュレーションが処理され、コンテキストが最適化されるため、予期せぬ動作を避けるために、Bean の生成に影響を与えるプロパティ(ブートストラップコンテキスト内で使用されるものなど)は、ビルド時と実行時に同じ値に設定する必要があります。
構成クライアントは、ネイティブイメージからの起動中に実行中のデータソース (構成サーバーなど) に接続するため、このネットワーク通信が行われるのに必要な時間だけ、高速起動時間が遅くなります。

付録

可観測性メタデータ

可観測性 - メトリクス

以下に、このプロジェクトで宣言されたすべての指標のリストを示します。

環境リポジトリ

EnvironmentRepository を中心に作成された観測。

指標名  spring.cloud.config.environment.find (規約クラス org.springframework.cloud.config.server.environment.ObservationEnvironmentRepositoryObservationConvention で定義)。タイプ  timer.

指標名  spring.cloud.config.environment.find.active (規約クラス org.springframework.cloud.config.server.environment.ObservationEnvironmentRepositoryObservationConvention で定義)。タイプ  long task timer.

観測の開始後に追加された KeyValues は、*.active メトリクスから欠落している可能性があります。
Micrometer は、ベースユニットに nanoseconds を内部的に使用します。ただし、各バックエンドが実際のベースユニットを決定します。(つまり、Prometheus は秒を使用します)

外側のクラス org.springframework.cloud.config.server.environment.DocumentedConfigObservation の完全修飾名。

すべてのタグには、spring.cloud.config.environment プレフィックスを付ける必要があります。
表 4: カーディナリティの低いキー

名前

説明

spring.cloud.config.environment.application (必須)

プロパティが照会されるアプリケーション名。

spring.cloud.config.environment.class (必須)

EnvironmentRepository の実装。

spring.cloud.config.environment.label (必須)

プロパティがクエリされるラベル。

spring.cloud.config.environment.profile (必須)

プロパティが照会されるアプリケーション名。

可観測性 - スパン

以下に、このプロジェクトで宣言されたすべてのスパンのリストを示します。

環境リポジトリのスパン

EnvironmentRepository を中心に作成された観測。

スパン名  spring.cloud.config.environment.find (規約クラス org.springframework.cloud.config.server.environment.ObservationEnvironmentRepositoryObservationConvention で定義)。

外側のクラス org.springframework.cloud.config.server.environment.DocumentedConfigObservation の完全修飾名。

すべてのタグには、spring.cloud.config.environment プレフィックスを付ける必要があります。
表 5: タグキー

名前

説明

spring.cloud.config.environment.application (必須)

プロパティが照会されるアプリケーション名。

spring.cloud.config.environment.class (必須)

EnvironmentRepository の実装。

spring.cloud.config.environment.label (必須)

プロパティがクエリされるラベル。

spring.cloud.config.environment.profile (必須)

プロパティが照会されるアプリケーション名。