testcontainers 8.7.2 → 8.8.0

package/dist/modules/kafka/kafka-container.d.ts

@@ -6,17 +6,42 @@ import { AbstractStartedContainer } from "../abstract-started-container";
 import { Host } from "../../docker/types";
 import { InspectResult } from "../../docker/functions/container/inspect-container";
 export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:5.5.4";
+interface SaslSslListenerOptions {
+    sasl: SaslOptions;
+    port: number;
+    keystore: PKCS12CertificateStore;
+    truststore?: PKCS12CertificateStore;
+}
+interface SaslOptions {
+    mechanism: "SCRAM-SHA-256" | "SCRAM-SHA-512";
+    user: User;
+}
+interface User {
+    name: string;
+    password: string;
+}
+interface PKCS12CertificateStore {
+    content: Parameters<GenericContainer["withCopyContentToContainer"]>[0];
+    passphrase: string;
+}
 export declare class KafkaContainer extends GenericContainer {
     private readonly uuid;
     private isZooKeeperProvided;
     private zooKeeperHost?;
     private zooKeeperPort?;
+    private saslSslConfig?;
     constructor(image?: string);
     withZooKeeper(host: Host, port: Port): this;
+    withSaslSslListener(options: SaslSslListenerOptions): this;
     protected preStart(): Promise<void>;
     start(): Promise<StartedKafkaContainer>;
     protected postStart(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
+    private addPlaintextAndSecureListener;
+    private addPlaintextListener;
+    private updateAdvertisedListeners;
+    private createUser;
 }
 export declare class StartedKafkaContainer extends AbstractStartedContainer {
     constructor(startedTestContainer: StartedTestContainer);
 }
+export {};

package/dist/modules/kafka/kafka-container.js

@@ -13,7 +13,6 @@ exports.StartedKafkaContainer = exports.KafkaContainer = exports.KAFKA_IMAGE = v
 const generic_container_1 = require("../../generic-container/generic-container");
 const uuid_1 = require("../../uuid");
 const abstract_started_container_1 = require("../abstract-started-container");
-const docker_client_1 = require("../../docker/docker-client");
 const KAFKA_PORT = 9093;
 const KAFKA_BROKER_PORT = 9092;
 const DEFAULT_ZOOKEEPER_PORT = 2181;
@@ -25,7 +24,6 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         this.isZooKeeperProvided = false;
         this.withExposedPorts(KAFKA_PORT)
             .withStartupTimeout(180000)
-            .withEnv("KAFKA_LISTENERS", `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`)
             .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT")
             .withEnv("KAFKA_INTER_BROKER_LISTENER_NAME", "BROKER")
             .withEnv("KAFKA_BROKER_ID", "1")
@@ -42,10 +40,20 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         this.zooKeeperPort = port;
         return this;
     }
+    withSaslSslListener(options) {
+        this.saslSslConfig = options;
+        return this;
+    }
     preStart() {
         return __awaiter(this, void 0, void 0, function* () {
             const network = this.networkMode && this.networkAliases.length > 0 ? this.networkAliases[0] : "localhost";
             this.withEnv("KAFKA_ADVERTISED_LISTENERS", `BROKER://${network}:${KAFKA_BROKER_PORT}`);
+            if (this.saslSslConfig) {
+                this.addPlaintextAndSecureListener(this.saslSslConfig);
+            }
+            else {
+                this.addPlaintextListener();
+            }
             let command = "#!/bin/bash\n";
             if (this.isZooKeeperProvided) {
                 this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${this.zooKeeperHost}:${this.zooKeeperPort}`);
@@ -74,9 +82,41 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         });
     }
     postStart(container, inspectResult, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updateAdvertisedListeners(container, inspectResult, boundPorts);
+            if (this.saslSslConfig) {
+                yield this.createUser(container, this.saslSslConfig.sasl);
+            }
+        });
+    }
+    addPlaintextAndSecureListener({ port, sasl, keystore, truststore }) {
+        this.withEnv("KAFKA_LISTENERS", `SECURE://0.0.0.0:${port},PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`)
+            .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SECURE:SASL_SSL")
+            .withEnv("KAFKA_SSL_PROTOCOL", "TLSv1.2")
+            .withCopyContentToContainer(keystore.content, "/etc/kafka/secrets/server.keystore.pfx")
+            .withEnv("KAFKA_SSL_KEYSTORE_LOCATION", "/etc/kafka/secrets/server.keystore.pfx")
+            .withEnv("KAFKA_SSL_KEYSTORE_PASSWORD", keystore.passphrase)
+            .withEnv("KAFKA_SSL_KEYSTORE_TYPE", "PKCS12")
+            .withEnv("KAFKA_SASL_ENABLED_MECHANISMS", sasl.mechanism)
+            .withEnv(`KAFKA_LISTENER_NAME_SECURE_${sasl.mechanism}_SASL_JAAS_CONFIG`, "org.apache.kafka.common.security.scram.ScramLoginModule required;")
+            .addExposedPorts(KAFKA_PORT, port);
+        if (truststore) {
+            this.withCopyContentToContainer(truststore.content, "/etc/kafka/secrets/server.truststore.pfx")
+                .withEnv("KAFKA_SSL_TRUSTSTORE_LOCATION", "/etc/kafka/secrets/server.truststore.pfx")
+                .withEnv("KAFKA_SSL_TRUSTSTORE_PASSWORD", truststore.passphrase)
+                .withEnv("KAFKA_SSL_TRUSTSTORE_TYPE", "PKCS12");
+        }
+    }
+    addPlaintextListener() {
+        this.withEnv("KAFKA_LISTENERS", `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`).addExposedPorts(KAFKA_PORT);
+    }
+    updateAdvertisedListeners(container, inspectResult, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             const brokerAdvertisedListener = `BROKER://${inspectResult.hostname}:${KAFKA_BROKER_PORT}`;
-            const bootstrapServers = `PLAINTEXT://${(yield docker_client_1.dockerClient).host}:${boundPorts.getBinding(KAFKA_PORT)}`;
+            let bootstrapServers = `PLAINTEXT://${container.getHost()}:${boundPorts.getBinding(KAFKA_PORT)}`;
+            if (this.saslSslConfig) {
+                bootstrapServers = `${bootstrapServers},SECURE://${container.getHost()}:${boundPorts.getBinding(this.saslSslConfig.port)}`;
+            }
             const { output, exitCode } = yield container.exec([
                 "kafka-configs",
                 "--alter",
@@ -94,6 +134,27 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             }
         });
     }
+    createUser(container, { user: { name, password }, mechanism }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { output, exitCode } = yield container.exec([
+                "kafka-configs",
+                "--alter",
+                // At the time of writing kafka-configs displays a warning stating that the 'zookeeper' flag is deprecated in favor of 'bootstrap-server'.
+                // Unfortunately, 'bootstrap-server' can only be used to set quotas and not to create a user.
+                "--zookeeper",
+                this.env["KAFKA_ZOOKEEPER_CONNECT"],
+                "--entity-type",
+                "users",
+                "--entity-name",
+                `${name}`,
+                "--add-config",
+                `${mechanism}=[password=${password}]`,
+            ]);
+            if (exitCode !== 0) {
+                throw new Error(`Kafka container configuration failed with exit code ${exitCode}: ${output}`);
+            }
+        });
+    }
 }
 exports.KafkaContainer = KafkaContainer;
 class StartedKafkaContainer extends abstract_started_container_1.AbstractStartedContainer {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "8.7.2",
+  "version": "8.8.0",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [