1. Home
  2. Confluent for Kubernetes
  3. Confluent Platform の構成
  4. Confluent for Kubernetes でのセキュリティの構成

Confluent for Kubernetes を使用した認証の構成

デフォルトでは、Confluent Platform コンポーネントで認証は構成されません。このドキュメントでは、サポートされている認証の概念を紹介するとともに、Confluent for Kubernetes （CFK）を使用して Confluent Platform の認証を構成する方法について説明します。

For more details on security concepts in Confluent Platform, see Security.

認証の構成に関する包括的なチュートリアルシナリオについては、「Deploy Secure Confluent Platform」を参照してください。

認証の概要

Kafka をはじめとする Confluent コンポーネントに接続するユーザーとアプリケーションの ID は認証によって検証されます。

Kafka にアクセスするための認証

Kafka にアクセスするクライアントアプリケーションと Confluent Platform コンポーネントについて、CFK は次の認証メカニズムをサポートしています。

  • SASL/PLAIN authentication: Clients use a username/password for authentication. The username/passwords are stored server-side in Kubernetes Secrets.
  • LDAP による SASL/PLAIN 認証: クライアントの認証にはユーザー名とパスワードが使用されます。ユーザー名とパスワードは LDAP サーバーに格納されます。
  • mTLS authentication: Clients use TLS certificates for authentication. The certificate has a CN that identifies the client application principal name.

ZooKeeper にアクセスするための認証

ZooKeeper にアクセスする Kafka について、CFK は次の認証メカニズムをサポートしています。

Authentication to access Confluent Platform components

CFK supports the following authentication mechanisms for the components, specifically Connect, ksqlDB, Schema Registry, and Confluent Control Center:

  • Basic authentication: Username/password for authentication, where the username/passwords are stored in Kubernetes Secrets.
  • mTLS 認証: クライアントの認証には TLS 証明書が使用されます。
  • LDAP 認証（Confluent Control Center のみ）: ユーザープリンシパルとパスワードの認証情報が LDAP サーバーに格納されます。

MDS にアクセスするための認証

Metadata Service (MDS) にアクセスするクライアントアプリケーションと Confluent Platform コンポーネントについて、CFK は次の認証メカニズムをサポートしています。

Kafka にアクセスするための認証の構成

SASL/PLAIN 認証

SASL/PLAIN は、ユーザー名とパスワードによるシンプルなメカニズムで、セキュアな認証を実装するために、一般には TLS ネットワーク暗号化を併用します。

ユーザー名は認証されたプリンシパルとして使用され、このプリンシパルが認可に使用されます。

Configure SASL/PLAIN as Kafka authentication mechanism

Configure a Kafka listener, in the Kafka custom resource (CR), to use SASL/PLAIN as the authentication mechanism:

spec:
  ...
  listeners:
    external:
      authentication:
        type: plain                 --- [1]
        jaasConfig:                 --- [2]
          secretRef:                --- [3]
        jaasConfigPassThrough:      --- [4]
          secretRef:                --- [5]
          directoryPathInContainer: --- [6]

  • [1]（必須）``plain`` に設定します。

  • One of [3], [5], or [6] is required.

  • [2] jaasConfig を使用する場合は、ユーザー名とパスワードを指定します。後は CFK が自動的に構成します。たとえば、ユーザーを追加、削除、アップデートすると、CFK が自動的に JAAS 構成をアップデートします。Kafka に SASL/PLAIN を構成する場合は、この方法を推奨します。

    • [3] Provide a Kubernetes Secret with a list of usernames and passwords.

      The expected key (the file name) is plain-users.json.

      The value for the key (the data in the file) is:

      {
"username1": "password1",
"username2": "password2",
"username3": "password3"
}

  • [4] JAAS を構成するには、jaasConfigPassThrough を使用する方法もあります。カスタムのログインハンドラーを使用するなど、カスタマイズが必要な場合は、CFK による自動構成を使用せずに構成を直接指定することができます。

    • [5] Provide a Kubernetes Secret with the expected key and the value.

      The expected key (the file name) is plain-jaas.conf.

      The expected value for the key (the data in the file) is your JAAS config text. See this Confluent Platform doc for understanding JAAS configs. The following example uses the standard login module and specifies two additional users:

      sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="admin" \
   password="admin-secret" \
   user_admin="admin-secret" \
   user_user1="user1-secret" \
   user_user2=”user2-secret”;

    • [6] Provide the required credential from the directory path in the container.

      The expected key (file name) is plain-jaas.conf. If jaasConfigPassThrough.directoryPathInContainer is configured as /vaults/secrets, the expected file, plain-jaas.conf, exists in the directory path.

      The following example for the expected value for the key (the data in the file) uses the standard login module and specifies two additional users:

      sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="admin" \
   password="admin-secret" \
   user_admin="admin-secret" \
   user_user1="user1-secret" \
   user_user2=”user2-secret”;

      Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

      Vault での directoryPathInContainer プロパティの使い方については、GitHub の CFK サンプル を参照してください。

Configure Confluent components to authenticate to Kafka using SASL/PLAIN

Kafka と通信を行う Confluent コンポーネントごとに、コンポーネントの CR で次のように SALS/PLAIN 認証を構成します。

spec:
  ...
  dependencies:
    kafka:
      authentication:
        type: plain                 --- [1]
        jaasConfig:                 --- [2]
          secretRef:                --- [3]
        jaasConfigPassThrough:      --- [4]
          secretRef:                --- [5]
          directoryPathInContainer: --- [6]

  • [1]（必須）``plain`` に設定します。

  • One of [2] or [4] is required.

  • [2] jaasConfig を使用する場合は、ユーザー名とパスワードを指定します。後は CFK が自動的に構成します。たとえば、ユーザーを追加、削除、アップデートすると、CFK が自動的に JAAS 構成をアップデートします。

    • [3] Provide a Kubernetes Secret with the username/password used to authenticate to Kafka.

      The expected key (filename) is plain.txt.

      The expected value for the key (the data in the file) is:

      username=<username>
password=<password>

  • [4] JAAS を構成するには、jaasConfigPassThrough を使用する方法もあります。カスタムのログインハンドラーを使用するなど、カスタマイズが必要な場合は、CFK による自動構成を使用せずに構成を直接指定することができます。

    • [5] Provide a Kubernetes Secret with the expected key and the value.

      The expected key (filename) is plain-jaas.conf.

      The expected value for the key (the data in the file) is your JAAS config text. See this Confluent Platform doc for understanding JAAS configs. The following example uses the standard login module and specifies two additional users:

      sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="admin" \
   password="admin-secret" \
   user_admin="admin-secret" \
   user_user1="user1-secret" \
   user_user2="user2-secret";

    • [6] Provide the required credential from the directory path in the container.

      The expected key (file name) is plain-jaas.conf.

      If jaasConfigPassThrough.directoryPathInContainer is configured as /vaults/secrets, the expected file, plain-jaas.conf, exists in the directory path. The following example for the expected value for the key (the data in the file) uses the standard login module and specifies two additional users:

      sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="admin" \
   password="admin-secret" \
   user_admin="admin-secret" \
   user_user1="user1-secret" \
   user_user2="user2-secret";

      Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

      Vault での directoryPathInContainer プロパティの使い方については、GitHub の CFK サンプル を参照してください。

LDAP による SASL/PLAIN 認証

LDAP による SASL/PLAIN コールバックハンドラーは SASL/PLAIN のバリエーションです。認証に LDAP による SASL/PLAIN を使用する場合、ユーザー名プリンシパルとパスワードは LDAP サーバーから取得されます。

Configure SASL/PLAIN with LDAP as Kafka authentication mechanism

You must set up an LDAP server, for example, AD, before configuring and starting up a Kafka cluster with the SASL/PLAIN with LDAP authentication. For more information, see Configuring Kafka Client Authentication with LDAP.

注釈

If you configure any Kafka listeners with the SASL/PLAIN authentication mode along with a SASL/PLAIN LDAP listener, you must use authentication.jaasConfigPassThrough for the SASL/PLAIN listener with PlainLoginModule. You cannot use authentication.jaasConfig for the SASL/PLAIN listener, and you cannot use FileBasedLoginModule.

To use SASL/PLAIN with LDAP as the authentication mechanism:

  1. Kafka のカスタムリソース（CR）でリスナーを構成します。

    spec:
  listeners:
    internal:
      authentication:
        type: ldap                 --- [1]
        jaasConfig:                --- [2]
          secretRef:               --- [3]
        jaasConfigPassThrough:     --- [4]
          secretRef:               --- [5]
          directoryPathInContainer:--- [6]
    external:
      authentication:
        type: ldap                 --- [7]
    custom:
      authentication:
        type: ldap                 --- [8]

    • [1] 内部の Kafka リスナー向けの LDAP による SASL/PLAIN 認証に必須です。

    • [2] 認証情報を渡すために jaasConfig を使用する場合は、ユーザー名とパスワードを指定します。後は CFK が自動的に構成します。ユーザーを追加、削除、アップデートすると、CFK が自動的に JAAS 構成をアップデートします。Kafka に SASL/PLAIN LDAP を構成する場合は、この方法を推奨します。

    • [3] For jaasConfig, provide a Kubernetes Secret with the user name and password for inter-broker authentication.

      The expected key (the file name) is plain-interbroker.txt.

      The value for the key (the data in the file) is:

      username=kafka
password=kafka-secret

      ユーザー名とパスワードは、LDAP に存在するユーザーのものである必要があります。クラスターが起動すると、各 Kafka ブローカーがこのユーザーを認証します。

    • [4] JAAS を構成するには、jaasConfigPassThrough を使用する方法もあります。カスタムのログインハンドラーを使用するなど、カスタマイズが必要な場合は、CFK による自動構成を使用せずに構成を直接指定することができます。

      • [5] Provide a Kubernetes Secret with the expected key and the value.

        The expected key (the file name) is plain-jaas.conf.

        The expected value for the key (the data in the file) is your JAAS config text:

        sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="kafka" \
   password="kafka-secret";

        See this Confluent Platform document for understanding JAAS configs.

      • [6] Provide the required credential from the directory path in the container.

        The expected key (file name) is plain-jaas.conf. If jaasConfigPassThrough.directoryPathInContainer is configured as /vaults/secrets, the expected file, plain-jaas.conf, exists in the directory path.

        The expected value for the key (the data in the file) is your JAAS config text:

        sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
   username="kafka" \
   password="kafka-secret";

      Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

    • [7] 外部の Kafka リスナー向けの LDAP による SASL/PLAIN 認証に必須です。

    • [8] カスタム Kafka リスナー向けの LDAP による SASL/PLAIN 認証に必須です。

    • [7] [8] 外部のリスナーまたはカスタムリスナーに認証タイプ ldap を構成する場合、jaasConfig または jaasConfigPassThrough を指定する必要はありません。

  2. Kafka の CR で ID プロバイダーを構成します。

    spec:
  identityProvider:                --- [1]
    type: ldap                     --- [2]
    ldap:                          --- [3]
      address:                     --- [4]
      authentication:              --- [5]
        type:                      --- [6]
        simple:                    --- [7]
      tls:
        enabled:                   --- [8]
      configurations:              --- [9]

    • [1] Kafka の認証タイプ ldap に必須です。ID プロバイダーの構成を指定します。

      MDS が有効になっている場合はこのプロパティが無視され、spec.services.mds.provider の LDAP 構成が使用されます。

    • [2]（必須）

    • [3] このブロックには、この Kafka の CR の spec.services.mds.provider.ldap ブロックで使用されているものと同じプロパティが含まれます。

    • [4]（必須）``ldaps://ldap.confluent.svc.cluster.local:636`` など、LDAP サーバーのアドレス。

    • [5]（必須）LDAP サーバーにアクセスするための認証方法。

    • [6]（必須）``simple`` または mtls を指定します。

    • [7] 認証タイプ（[6]）が simple に設定された場合に必須です。

    • [8] 認証タイプ（[6]）が mtls に設定された場合に必須です。true に設定します。

    • [9]（必須）LDAP 構成設定。

  3. 構成を適用します。

    kubectl apply -f <Kafka CR>

Configure Confluent components to authenticate to Kafka using SASL/PLAIN with LDAP

LDAP による SASL/PLAIN が Kafka に構成されている場合、Confluent のコンポーネントとクライアントは SASL/PLAIN クライアントとして Kafka に対する認証を行います。クライアントは LDAP 内のユーザーとして認証を行う必要があります。

構成の詳細については、「Configure Confluent components to authenticate to Kafka using SASL/PLAIN」を参照してください。

mTLS 認証

Configure mTLS as Kafka authentication mechanism

mTLS では、認証メカニズムとして TLS 証明書が利用されます。この証明書によって ID が示されます。

証明書の CN（Common Name: 一般名）は認証されたプリンシパルとして使用され、このプリンシパルが認可に使用されます。

認証メカニズムとして mTLS を使用するには、次のように Kafka リスナーを Kafka の CR で構成します。

spec:
  ...
  listeners:
    external:
      authentication:
        type: mtls                                     --- [1]
        principalMappingRules:
        - RULE:.*CN[\s]?=[\s]?([a-zA-Z0-9.]*)?.*/$1/   --- [2]
      tls:
        enabled: true                                  --- [3]

  • [1]（必須）``mTLS`` に設定します。

  • [2]（省略可）証明書の CN（Common Name: 一般名）からプリンシパル名を抽出するマッピングルールを指定します。

    マッピングルールに使用される正規表現（regex）は Java マッピング API です。正規表現の検証には、「Regular Expression Test Drive」などのサイトを使用できます。

  • [3]（mTLS 認証では必須）``true`` に設定します。

Configure Confluent components to authenticate to Kafka using mTLS

Kafka と通信を行う Confluent コンポーネントごとに、コンポーネントの CR で次のように mTLS 認証メカニズムを構成します。

spec:
  ...
  dependencies:
    kafka:
      authentication:
        type: mtls               --- [1]
      tls:
        enabled: true            --- [2]
  • [1]（必須）``mtls`` に設定します。
  • [2]（mTLS 認証では必須）``true`` に設定します。

ZooKeeper にアクセスするための認証の構成

SASL/DIGEST 認証

Configure DIGEST as ZooKeeper authentication

ZooKeeper は、SASL DIGEST-MD5 メカニズムを使用した認証をサポートします。

Enable DIGEST authentication in the ZooKeeper CR as below:

spec:
  ...
  authentication:
    type: digest                 --- [1]
    jaasConfig:                  --- [2]
      secretRef:                 --- [3]
    jaasConfigPassThrough:       --- [4]
      secretRef:                 --- [5]
      directoryPathInContainer:  --- [6]

  • [1]（必須）``digest`` に設定します。

  • One of [2], [3], or [4] is required.

  • [2] jaasConfig を使用する場合は、ユーザー名とパスワードを指定します。後は CFK が自動的に構成します。たとえば、ユーザーを追加、削除、アップデートすると、CFK が自動的に JAAS 構成をアップデートします。ZooKeeper に SASL/DIGEST を構成する場合は、この方法を推奨します。

    • [3] Provide a Kubernetes Secret with the username/passwords.

      The expected key (the file name) is digest-users.json.

      The expected value for the key (the data in the file) is:

      {
"username1": "password1",
"username2": "password2"
}

  • [4] JAAS を構成するには、jaasConfigPassThrough を使用する方法もあります。カスタムのログインハンドラーを使用するなど、カスタマイズが必要な場合は、CFK による自動構成を使用せずに構成を直接指定することができます。

    • [5] Provide a Kubernetes Secret with the expected key and the value. The expected key (the file name) is digest-jaas.conf. The expected value for the key (data in the file) is:

      Server {
  org.apache.zookeeper.server.auth.DigestLoginModule required
    user_super="adminsecret"
    user_user1="user1-secret";
 };

    • [6] Provide the required credential from the directory path in the container. The expected key/file name is digest-jaas.conf.

      If jaasConfigPassThrough.directoryPathInContainer is configured as /vaults/secrets, the expected file, digest-jaas.conf, exists in the directory path. The following example for the expected value for the key (the data in the file) uses the standard login module and specifies one additional user:

      Server {
  org.apache.zookeeper.server.auth.DigestLoginModule required
    user_super="adminsecret"
    user_bob="bob-secret";
};

      Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

      Vault での directoryPathInContainer プロパティの使い方については、GitHub の CFK サンプル を参照してください。

Configure Kafka to authenticate to ZooKeeper using digest

For Kafka to authenticate to ZooKeeper using digest authentication, configure the Kafka CR as below:

spec:
  ...
  dependencies:
    zookeeper:
      authentication:
        type: digest                --- [1]
        jaasConfig:                 --- [2]
          secretRef:                --- [3]
        jaasConfigPassThrough:      --- [4]
          secretRef:                --- [5]
          directoryPathInContainer: --- [6]

  • [1]（必須）``digest`` に設定します。

  • One of [2], [3], or [4] is required.

  • [2] jaasConfig を使用する場合は、ユーザー名とパスワードを指定します。後は CFK が自動的に構成します。たとえば、ユーザーを追加、削除、アップデートすると、CFK が自動的に JAAS 構成をアップデートします。ZooKeeper に SASL/DIGEST を構成する場合は、この方法を推奨します。

    • [3] Provide a Kubernetes Secret with the username/password used to authenticate to ZooKeeper.

      The expected key (the file name) is digest.txt.

      The value for the key (the data in the file) is shown below. Double quotes are required around the username and password.

      username="<username>"
password="<password>"

  • [4] JAAS を構成するには、jaasConfigPassThrough を使用する方法もあります。カスタムのログインハンドラーを使用するなど、カスタマイズが必要な場合は、CFK による自動構成を使用せずに構成を直接指定することができます。

    • [5] Provide a Kubernetes Secret with the expected key and the value.

      The expected key and filename is digest-jaas.conf.

      The following is an example value (the data in the file) for digest-jaas.conf with a standard login module and a user. The expected value for the key (the data in the file) is:

      Client { //zookeeper dependencies
    org.apache.zookeeper.server.auth.DigestLoginModule required
    username="bob"
    password="password";
};

mTLS 認証

Configure mTLS as ZooKeeper authentication

ZooKeeper の CR で、次のように mTLS 認証を有効にします。

spec:
  ...
  authentication:
    type: mtls

Configure Kafka to authenticate to ZooKeeper using mTLS

ZooKeeper に対する Kafka の認証に mTLS 認証を使用するためには、Kafka の CR を次のように構成します。

spec:
  ...
  dependencies:
    zookeeper:
      authentication:
        type: mtls               --- [1]
      tls:
        enabled: true            --- [2]
  • [1]（必須）``mtls`` に設定します。
  • [2]（mTLS 認証では必須）``true`` に設定します。

Configure authentication to access Confluent Platform components

基本認証

Configure basic authentication for Confluent Platform components

The credentials are stored on the server side, in the following format: <username>: <password>, <role that user is assigned to>

The following roles are supported, by default:

  • REST Proxy: admin、developer、user、krp-user の各ロールを使用できます。
  • ksqlDB: admin、developer、user、ksql-user の各ロールを使用できます。
  • Schema Registry: admin、developer、user、sr-user の各ロールが利用できます。
  • Confluent Control Center: Administrators ロールと Restricted ロールが利用できます。

警告

Connect については、ロールがサポートされません。

Configure basic authentication in the component CR as below:

spec:
  ...
  authentication:
    type: basic                  --- [1]
    basic:
      secretRef:                 --- [2]
      directoryPathInContainer:  --- [3]
      restrictedRoles:           --- [4]
      roles:                     --- [5]

  • [1]（必須）``basic`` に設定します。

  • [2] or [3] Required.

  • [2] Provide a Kubernetes Secret with the username/passwords.

    The expected key is basic.txt.

    The value for the key is:

    username1: password1,role1
username2: password2,role2

  • [3] Provide the path where required credentials are injected by Vault. See [2] above for the expected key and the value.

    Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

    Vault での directoryPathInContainer プロパティの使い方については、GitHub の CFK サンプル を参照してください。

  • [4]（省略可）|c3| におけるサーバー上の限定ロールのリストです。

  • [5]（省略可）サーバー側のロールのリストです。

Configure Confluent components to authenticate to other Confluent Platform component using basic authentication

基本認証に使用されるユーザー名とパスワードは、secretRef または directoryPathInContainer を通じて読み込まれます。

警告

Confluent Control Center は、基本認証を使用した Connect と ksqlDB への接続をサポートしません。

Enable basic authentication in the component CR as below. <component> is the Confluent Platform component that this component needs to authenticate to:

spec:
  ...
  dependencies:
    <component>:
      url:
      authentication:
        type: basic                --- [1]
        basic:
          secretRef:               --- [2]
          directoryPathInContainer --- [3]

  • [1]（必須）``basic`` に設定します。

  • [2] or [3] are required.

  • [2] The username and password are loaded through secretRef.

    The expected key is is basic.txt.

    The value for the key is:

    username=<username>
password=<password>

  • [3] The username and password are loaded through Vault. See [2] above for the expected key and the value.

    Vault を使用する際の認証情報と必要なアノテーションを提供する方法については、「Confluent Platform コンポーネントの CR へのシークレットの提供」を参照してください。

mTLS 認証

Configure mTLS authentication for Confluent Platform components

Configure mTLS authentication in the component CR as below:

spec:
  ...
  authentication:
    type: mtls                --- [1]
  • [1]（必須）``mtls`` に設定します。

Configure Confluent components to authenticate to other Confluent Platform components using mTLS authentication

Enable mTLS authentication in the component CR as below. <component> is the Confluent Platform component that this component needs to authenticate to:

spec:
  ...
  dependencies:
    <component>:
      url:
      authentication:
        type: mtls               --- [1]
      tls:
        enabled: true            --- [2]
  • [1]（必須）``mtls`` に設定します。
  • [2]（mTLS 認証では必須）``true`` に設定します。

Confluent Control Center の LDAP 認証

In addition to basic and mTLS authentication methods, Confluent Control Center supports LDAP as an authentication method.

You can configure the Control Center CR to pull users and groups from an LDAP server:

kind: ControlCenter
spec:
  authentication:
    type: ldap                                      --- [1]
    ldap:
      secretRef:                                    --- [2]
      roles:                                        --- [3]
      restrictedRoles:                              --- [4]
      property:                                     --- [5]
        #  useLdaps: "true"
        #  contextFactory: "com.sun.jndi.ldap.LdapCtxFactory"
        #  hostname: ""
        #  port: "389"
        #  bindDn: ""
        #  bindPassword: ""
        #  authenticationMethod: ""
        #  forceBindingLogin: "true"
        #  userBaseDn: ""
        #  userRdnAttribute: "sAMAccountName"
        #  userIdAttribute: "sAMAccountName"
        #  userPasswordAttribute: "userPassword"
        #  userObjectClass: "user"
        #  roleBaseDn: ""
        #  roleNameAttribute: "cn"
        #  roleMemberAttribute: "member"
        #  roleObjectClass: "group"

  • [1]（必須）``ldap`` に設定します。

  • [2] Secret for LDAP credentials.

    The expected key is ldap.txt.

    The value for the key is:

    username=<bindDn_value>
password=<bindPassword_value>

    If you have security considerations, pass empty values for bindDn and bindPassword in the CR. The CFK will replace them and add them as appropriately.

    bindDn のパスワードでは、制限されているすべての LDAP 文字を エスケープ します。最適な結果を得るために、エスケープが必要な文字を使用しないことをお勧めします。LDAP 命名属性のベストプラクティス に従ってください。

  • [3]（省略可）デフォルトでは、["Administrators", "Restricted"] に設定されます。

  • [4]（省略可）アクセスが読み取り専用に制限されているロールのリストです。Control Center での編集や作成は許可されません。

  • [5]（必須）詳細については、「LdapLoginModule の構成」を参照してください。

Confluent Control Center の LDAP over SSL 認証

When configuring Control Center for encryption and authentication using LDAP over SSL (LDAPS), the LDAPS truststore must be exported to the JVM using the configOverrides feature.

この要件は、Control Center が外部の MDS を使用して認証を行う RBAC が有効な環境には適用されません。

Add the LDAP SSL certificate to the JVM truststore in the Confluent Control Center CR as shown below:

spec:
  configOverrides:
    jvm:
      -Djavax.net.ssl.trustStore=<path to truststore.jks>
      -Djavax.net.ssl.trustStorePassword=<password for the truststore>

MDS にアクセスするための認証の構成

ベアラー認証

MDS と通信を行う Confluent コンポーネントごとに、コンポーネントの CR で次のようにベアラー認証メカニズムを構成します。

spec:
  dependencies:
    mds:
      authentication:
        type: bearer               --- [1]
        bearer:
          secretRef:               --- [2]

  • [1]（必須）``bearer`` に設定します。

  • [2]（必須）

    The username and password are loaded through secretRef.

    想定されるキーは bearer.txt です。

    The value for the key is:

    username=<username>
password=<password>

RBAC が有効になっている場合（spec.authorization.type: rbac）、CFK は常に Confluent コンポーネントにベアラー認証を使用し、spec.authentication 設定を無視します。RBAC が有効になっている状態でコンポーネントの認証タイプを mTLS に設定することはできません。