Couchbase 5桶密码设置

Question

我正在尝试编写示例以学习 couchbase。我正在尝试将它与 spring 引导一起使用，它是 crud 存储库。

所以我下载了最新的 docker 图片，但问题是：我找不到存储桶的密码。 Couchbase 控制台仅允许用户创建，但在 spring 中，没有像 username/password 这样的等效用法。它只允许似乎与 couchbase 5 不兼容的 bucketName 和密码。

我是不是遗漏了什么或者 spring 与 couchbase 5 不兼容？如果spring不兼容，couchbase哪个版本可以？

感谢

Answer 1

Spring Data Couchbase 与 Couchbase Server 5.0 兼容。您可以通过创建与存储桶同名的用户来实现与 4.x 相同的身份验证，然后只需使用来自 Spring 数据的存储桶名称和密码（如果它早于 3.0/Kay。[=13） =]

文档应该涵盖这一点，如果有任何令人困惑的地方，请单击 "feedback" 按钮并提供可以改进的地方！

https://developer.couchbase.com/documentation/server/5.0/security/security-authorization.html https://developer.couchbase.com/documentation/server/5.0/security/concepts-rba-for-apps.html https://developer.couchbase.com/documentation/server/5.0/security/security-resources-under-access-control.html

Answer 2

Couchbase 驱动程序支持使用 username/password 连接到 Couchbase 5 存储桶。问题是 spring-data-couchbase 的开发速度不够快，无法涵盖 Couchbase 引入的所有新功能。因此，我们需要帮助 Spring 使用新的桶连接，通过覆盖 spring-data-couchbase 配置基础 class - org.springframework.data.couchbase.config.AbstractCouchbaseConfiguration 的 Couchbase 集群实例化方法来实现。这是我们正在研究的方法：

@Override
@Bean(name = BeanNames.COUCHBASE_CLUSTER_INFO)
public ClusterInfo couchbaseClusterInfo() throws Exception {
return couchbaseCluster().clusterManager(getBucketName(), getBucketPassword()).info();
}

如我们所见，它不使用用户名，只使用存储桶和密码，因此在我们的配置中，我们将按如下方式覆盖它：

@Override
@Bean(name = BeanNames.COUCHBASE_CLUSTER_INFO)
public ClusterInfo couchbaseClusterInfo() throws Exception {
return couchbaseCluster().authenticate(couchbaseUsername, couchbasePassword).clusterManager().info();
}

就是这样。这是我的 spring-data-couchbase 配置的完整代码：

import com.couchbase.client.java.Bucket;
import com.couchbase.client.java.cluster.ClusterInfo;
import com.couchbase.client.java.env.CouchbaseEnvironment;
import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.data.couchbase.config.AbstractCouchbaseConfiguration;
import org.springframework.data.couchbase.config.BeanNames;
import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;

import javax.inject.Inject;
import java.security.KeyStore;
import java.util.List;

/**
 * @author by avoinovan
 */
@Configuration
@EnableCouchbaseRepositories
public class ModelConfig extends AbstractCouchbaseConfiguration {

    private final static int DEFAULT_HTTP_PORT = 8091;
    private final static int DEFAULT_HTTP_SSL_PORT = 18091;
    private final static int DEFAULT_CARRIER_PORT = 11210;
    private final static int DEFAULT_CARRIER_SSL_PORT = 11207;

    private final static long DEFAULT_KEEP_ALIVE_INTERVAL = 30000;
    private final static int DEFAULT_SOCKET_CONNECT_TIMEOUT_MS = 5000;
    private final static long DEFAULT_CONNECT_TIMEOUT_MS = 5000;
    private final static long DEFAULT_MANAGEMENT_TIMEOUT_MS = 75000;
    private final static long DEFAULT_DISCONNECT_TIMEOUT_MS = 25000;

    private final static String PROPERTY_KEEP_ALIVE_INTERVAL_MS = "couchbase.keep_alive_interval_ms";

    private final static String PROPERTY_SOCKET_CONNECT_TIMEOUT_MS = "couchbase.socket_connect_timeout_ms";
    private final static String PROPERTY_CONNECT_TIMEOUT_MS = "couchbase.connect_timeout_ms";
    private final static String PROPERTY_MANAGEMENT_TIMEOUT_MS = "couchbase.management_timeout_ms";
    private final static String PROPERTY_DISCONNECT_TIMEOUT_MS = "couchbase.disconnect_timeout_ms";

    private final static String PROPERTY_SSL_ENABLED = "couchbase.ssl.enabled";
    private final static String PROPERTY_SSL_KEYSTORE_FILE = "couchbase.ssl.keystore.file";
    private final static String PROPERTY_SSL_KEYSTORE_PASSWORD = "couchbase.ssl.keystore.password";
    private final static String PROPERTY_SSL_TRUSTSTORE_FILE = "couchbase.ssl.truststore.file";
    private final static String PROPERTY_SSL_TRUSTSTORE_PASSWORD = "couchbase.ssl.truststore.password";

    private final static String PROPERTY_BOOTSTRAP_HTTP_ENABLED = "couchbase.bootstrap.http.enabled";
    private final static String PROPERTY_BOOTSTRAP_HTTP_PORT = "couchbase.bootstrap.http.port";
    private final static String PROPERTY_BOOTSTRAP_HTTP_SSL_PORT = "couchbase.bootstrap.http.ssl.port";
    private final static String PROPERTY_BOOTSTRAP_CARRIER_ENABLED = "couchbase.bootstrap.carrier.enabled";
    private final static String PROPERTY_BOOTSTRAP_CARRIER_PORT = "couchbase.bootstrap.carrier.port";
    private final static String PROPERTY_BOOTSTRAP_CARRIER_SSL_PORT = "couchbase.bootstrap.carrier.ssl.port";

    @Value("#{'${spring.couchbase.bootstrap-hosts}'.split(',')}")
    private List<String> couchbaseBootstrapHosts;

    @Value("${spring.couchbase.bucket.name}")
    private String bucketName;

    @Value("${spring.couchbase.password}")
    private String couchbasePassword;

    @Value("${spring.couchbase.username}")
    private String couchbaseUsername;

    private final Environment environment;

    private final ResourceLoader resourceLoader;

    @Inject
    public ModelConfig(final Environment environment,
                       final ResourceLoader resourceLoader) {
        this.environment = environment;
        this.resourceLoader = resourceLoader;
    }

    protected List<String> getBootstrapHosts() {
        return couchbaseBootstrapHosts;
    }

    protected String getBucketName() {
        return bucketName;
    }

    protected String getBucketPassword() {
        return couchbasePassword;
    }

    protected CouchbaseEnvironment getEnvironment() {
        return DefaultCouchbaseEnvironment.builder()
                .keepAliveInterval(environment.getProperty(PROPERTY_KEEP_ALIVE_INTERVAL_MS,
                        Long.class,
                        DEFAULT_KEEP_ALIVE_INTERVAL))

                // timeout settings
                .socketConnectTimeout(environment.getProperty(PROPERTY_SOCKET_CONNECT_TIMEOUT_MS,
                        Integer.class,
                        DEFAULT_SOCKET_CONNECT_TIMEOUT_MS))
                .connectTimeout(environment.getProperty(PROPERTY_CONNECT_TIMEOUT_MS,
                        Long.class,
                        DEFAULT_CONNECT_TIMEOUT_MS))
                .managementTimeout(environment.getProperty(PROPERTY_MANAGEMENT_TIMEOUT_MS,
                        Long.class,
                        DEFAULT_MANAGEMENT_TIMEOUT_MS))
                .disconnectTimeout(environment.getProperty(PROPERTY_DISCONNECT_TIMEOUT_MS,
                        Long.class,
                        DEFAULT_DISCONNECT_TIMEOUT_MS))

                // port and ssl
                .sslEnabled(environment.getProperty(PROPERTY_SSL_ENABLED, Boolean.class, false))
                .bootstrapHttpEnabled(environment.getProperty(PROPERTY_BOOTSTRAP_HTTP_ENABLED,
                        Boolean.class,
                        Boolean.TRUE))
                .bootstrapHttpDirectPort(environment.getProperty(PROPERTY_BOOTSTRAP_HTTP_PORT,
                        Integer.class,
                        DEFAULT_HTTP_PORT))
                .bootstrapHttpSslPort(environment.getProperty(PROPERTY_BOOTSTRAP_HTTP_SSL_PORT,
                        Integer.class,
                        DEFAULT_HTTP_SSL_PORT))
                .bootstrapCarrierEnabled(environment.getProperty(PROPERTY_BOOTSTRAP_CARRIER_ENABLED,
                        Boolean.class,
                        Boolean.TRUE))
                .bootstrapCarrierDirectPort(environment.getProperty(PROPERTY_BOOTSTRAP_CARRIER_PORT,
                        Integer.class,
                        DEFAULT_CARRIER_PORT))
                .bootstrapCarrierSslPort(environment.getProperty(PROPERTY_BOOTSTRAP_CARRIER_SSL_PORT,
                        Integer.class,
                        DEFAULT_CARRIER_SSL_PORT))

                // keystore and trust store
                .sslKeystore(createKeyStore(environment, resourceLoader))
                .sslTruststore(createTrustStore(environment, resourceLoader))

                .build();
    }

    @Override
    @Bean(name = BeanNames.COUCHBASE_CLUSTER_INFO)
    public ClusterInfo couchbaseClusterInfo() throws Exception {
        return couchbaseCluster().authenticate(couchbaseUsername, couchbasePassword).clusterManager().info();
    }

    /**
     * Return the {@link Bucket} instance to connect to.
     *
     * @throws Exception on Bean construction failure.
     */
    @Override
    @Bean(destroyMethod = "close", name = BeanNames.COUCHBASE_BUCKET)
    public Bucket couchbaseClient() throws Exception {
        //@Bean method can use another @Bean method in the same @Configuration by directly invoking it
        return couchbaseCluster().openBucket(getBucketName());
    }

    private KeyStore createKeyStore(final Environment environment, final ResourceLoader resourceLoader) {
        return loadKeyStore(environment, resourceLoader, PROPERTY_SSL_KEYSTORE_FILE, PROPERTY_SSL_KEYSTORE_PASSWORD);
    }

    private KeyStore createTrustStore(final Environment environment, final ResourceLoader resourceLoader) {
        return loadKeyStore(environment, resourceLoader, PROPERTY_SSL_TRUSTSTORE_FILE, PROPERTY_SSL_TRUSTSTORE_PASSWORD);
    }

    private KeyStore loadKeyStore(final Environment environment,
                                  final ResourceLoader resourceLoader,
                                  final String fileProperty,
                                  final String passwordProperty) {
        String file = environment.getProperty(fileProperty);
        String password = environment.getProperty(passwordProperty);

        if (file != null) {
            Resource resource = resourceLoader.getResource(file);
            if (resource != null) {
                try {
                    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
                    keyStore.load(resource.getInputStream(), password == null ? null : password.toCharArray());
                    return keyStore;
                } catch (final Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return null;
    }
}

Answer 3

我遇到了同样的问题。我通过进入 AbstractCouchbaseConfiguration 开始调试，在那里我发现

public abstract class AbstractCouchbaseConfiguration
    extends AbstractCouchbaseDataConfiguration implements CouchbaseConfigurer {

  ....//some other configuration


@Override
@Bean(name = BeanNames.COUCHBASE_CLUSTER_INFO)
public ClusterInfo couchbaseClusterInfo() throws Exception {
  return couchbaseCluster().clusterManager(getBucketName(), getBucketPassword()).info();
}

我所做的是创建了一个与我的 couchbase 用户同名的存储桶。

couchbase 用户名：用户详细信息

沙发基地密码：******

存储桶名称：用户详细信息

Couchbase 5桶密码设置

Couchbase 5 bucket password setting

couchbase

spring-data

spring-boot

spring-data-couchbase