@gradientedge/cdk-utils-azure 2.12.0 → 2.13.0

package/dist/src/construct/rest-api-with-cache/main.d.ts

@@ -1,7 +1,7 @@
 import { AzureRestApi } from '../rest-api/main.js';
 import { AzureApiWithCache, AzureRestApiWithCacheProps } from './types.js';
 /**
- * Provides a construct to create and deploy an Azure API Management service with Redis cache integration
+ * Provides a construct to create and deploy an Azure API Management service with Azure Managed Redis (Enterprise) cache integration
  * @example
  * import { AzureRestApiWithCache, AzureRestApiWithCacheProps } from '@gradientedge/cdk-utils'
  *
@@ -24,7 +24,7 @@ export declare class AzureRestApiWithCache extends AzureRestApi {
      */
     initResources(): void;
     /**
-     * @summary Method to create the managed Redis cache instance
+     * @summary Method to create the Azure Managed Redis (Enterprise) cluster and database
      */
     protected createRedisCache(): void;
     /**

package/dist/src/construct/rest-api-with-cache/main.js

@@ -1,6 +1,8 @@
+import { listDatabaseKeysOutput } from '@pulumi/azure-native/redisenterprise/index.js';
+import * as pulumi from '@pulumi/pulumi';
 import { AzureRestApi } from '../rest-api/main.js';
 /**
- * Provides a construct to create and deploy an Azure API Management service with Redis cache integration
+ * Provides a construct to create and deploy an Azure API Management service with Azure Managed Redis (Enterprise) cache integration
  * @example
  * import { AzureRestApiWithCache, AzureRestApiWithCacheProps } from '@gradientedge/cdk-utils'
  *
@@ -32,38 +34,52 @@ export class AzureRestApiWithCache extends AzureRestApi {
         this.createRedisCacheApiManagement();
     }
     /**
-     * @summary Method to create the managed Redis cache instance
+     * @summary Method to create the Azure Managed Redis (Enterprise) cluster and database
      */
     createRedisCache() {
-        this.api.redis = this.redisManager.createManagedRedis(this.id, this, {
+        const result = this.redisManager.createManagedRedis(this.id, this, {
             ...this.props.apiManagementManagedRedis,
-            name: this.id,
+            clusterName: this.id,
             location: this.resourceGroup.location,
             resourceGroupName: this.resourceGroup.name,
-        }, { ignoreChanges: ['location'] });
+        }, this.props.apiManagementManagedRedisDatabase, { ignoreChanges: ['location'] });
+        this.api.redisCluster = result.cluster;
+        this.api.redisDatabase = result.database;
     }
     /**
      * @summary Method to create the Redis cache connection string secret in Key Vault
      */
     createRedisCacheSecret() {
+        const connectionString = pulumi
+            .all([
+            this.api.redisCluster.hostName,
+            this.api.redisCluster.name,
+            this.api.redisDatabase.name,
+            this.resourceGroup.name,
+        ])
+            .apply(([hostName, clusterName, databaseName, resourceGroupName]) => listDatabaseKeysOutput({
+            clusterName,
+            databaseName,
+            resourceGroupName,
+        }).apply(keys => `${hostName}:10000,password=${keys.primaryKey},ssl=True,abortConnect=False`));
         this.api.redisNamedValueSecret = this.keyVaultManager.createKeyVaultSecret(`${this.id}-key-vault-redis-namespace-secret`, this, {
             vaultName: this.api.authKeyVault.name,
-            secretName: `${this.api.redis.name}key`,
+            secretName: `${this.api.redisCluster.name}key`,
             resourceGroupName: this.resourceGroup.name,
             properties: {
-                value: `${this.api.redis.name}:10000,password=${this.api.redis.accessKeys.primaryKey},ssl=True,abortConnect=False`,
+                value: connectionString,
             },
-        }, { dependsOn: [this.api.redis, this.api.namedValueRoleAssignment] });
+        }, { dependsOn: [this.api.redisCluster, this.api.redisDatabase, this.api.namedValueRoleAssignment] });
     }
     /**
      * @summary Method to create the API Management named value for the Redis cache secret
      */
     createRedisCacheNamespace() {
         this.api.redisNamedValue = this.apiManagementManager.createNamedValue(`${this.id}-redis-nv`, this, {
-            displayName: `${this.api.redis.name}key`,
+            displayName: `${this.api.redisCluster.name}key`,
             resourceGroupName: this.resourceGroup.name,
             serviceName: this.api.apim.name,
-            namedValueId: `${this.api.redis.name}key`,
+            namedValueId: `${this.api.redisCluster.name}key`,
             secret: true,
             keyVault: {
                 secretIdentifier: this.api.redisNamedValueSecret.id,
@@ -77,9 +93,9 @@ export class AzureRestApiWithCache extends AzureRestApi {
         this.apiManagementManager.createCache(`${this.id}-am-redis-cache`, this, {
             serviceName: this.api.apim.name,
             connectionString: `{{${this.api.redisNamedValue.name}}}`,
-            cacheId: this.api.redis.id,
+            cacheId: this.api.redisCluster.id,
             resourceGroupName: this.resourceGroup.name,
-            useFromLocation: this.api.redis.location,
+            useFromLocation: this.api.redisCluster.location,
             description: `Redis cache for ${this.api.apim.name}`,
         });
     }

package/dist/src/construct/rest-api-with-cache/types.d.ts

@@ -1,15 +1,17 @@
 import { NamedValue } from '@pulumi/azure-native/apimanagement/index.js';
 import { Secret } from '@pulumi/azure-native/keyvault/index.js';
-import { Redis } from '@pulumi/azure-native/redis/index.js';
-import { RedisProps } from '../../index.js';
+import { Database, RedisEnterprise } from '@pulumi/azure-native/redisenterprise/index.js';
+import { RedisDatabaseProps, RedisEnterpriseClusterProps } from '../../index.js';
 import { AzureApi, AzureRestApiProps } from '../index.js';
 /** @category Interface */
 export interface AzureRestApiWithCacheProps extends AzureRestApiProps {
-    apiManagementManagedRedis: RedisProps;
+    apiManagementManagedRedis: RedisEnterpriseClusterProps;
+    apiManagementManagedRedisDatabase?: Partial<RedisDatabaseProps>;
 }
 /** @category Interface */
 export interface AzureApiWithCache extends AzureApi {
-    redis: Redis;
+    redisCluster: RedisEnterprise;
+    redisDatabase: Database;
     redisNamedValueSecret: Secret;
     redisNamedValue: NamedValue;
 }

package/dist/src/construct/site-with-webapp/main.js

@@ -22,7 +22,7 @@ import { CommonAzureConstruct } from '../../common/index.js';
 export class SiteWithWebApp extends CommonAzureConstruct {
     props;
     applicationInsights;
-    site;
+    site = {};
     constructor(id, props) {
         super(id, props);
         this.props = props;

package/dist/src/services/api-management/main.d.ts

@@ -1,4 +1,5 @@
-import * as redis from '@pulumi/azure-native/redis/index.js';
+import { Database, RedisEnterprise } from '@pulumi/azure-native/redisenterprise/index.js';
+import * as pulumi from '@pulumi/pulumi';
 import { ResourceOptions } from '@pulumi/pulumi';
 import { CommonAzureConstruct } from '../../common/index.js';
 import { ApiDiagnosticProps, ApiManagementApiProps, ApiManagementBackendProps, ApiManagementProps, ApiOperationPolicyProps, ApiOperationProps, ApiPolicyProps, ApiSubscriptionProps, CacheProps, LoggerProps, NamedValueProps, ResolveApiManagementProps } from './types.js';
@@ -27,11 +28,14 @@ export declare class AzureApiManagementManager {
      * @param scope scope in which this resource is defined
      * @param props API Management properties
      * @param applicationInsightsKey Optional Application Insights instrumentation key for logging
-     * @param externalRedisCache Optional external Redis cache for API Management caching
+     * @param externalRedisCache Optional external Azure Managed Redis (Enterprise) cluster and database for API Management caching
      * @param resourceOptions Optional settings to control resource behaviour
      * @see [Pulumi Azure Native API Management]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/apimanagementservice/}
      */
-    createApiManagementService(id: string, scope: CommonAzureConstruct, props: ApiManagementProps, applicationInsightsKey?: string, externalRedisCache?: redis.Redis, resourceOptions?: ResourceOptions): import("@pulumi/azure-native/apimanagement/apiManagementService.js").ApiManagementService;
+    createApiManagementService(id: string, scope: CommonAzureConstruct, props: ApiManagementProps, applicationInsightsKey?: string, externalRedisCache?: {
+        cluster: RedisEnterprise;
+        database: Database;
+    }, resourceOptions?: ResourceOptions): import("@pulumi/azure-native/apimanagement/apiManagementService.js").ApiManagementService;
     /**
      * @summary Method to resolve an existing API Management service
      * @param id scoped id of the resource
@@ -40,7 +44,7 @@ export declare class AzureApiManagementManager {
      * @param resourceOptions Optional settings to control resource behaviour
      * @see [Pulumi Azure Native API Management Lookup]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/apimanagementservice/}
      */
-    resolveApiManagementService(id: string, scope: CommonAzureConstruct, props: ResolveApiManagementProps, resourceOptions?: ResourceOptions): import("@pulumi/pulumi").Output<import("@pulumi/azure-native/apimanagement/getApiManagementService.js").GetApiManagementServiceResult>;
+    resolveApiManagementService(id: string, scope: CommonAzureConstruct, props: ResolveApiManagementProps, resourceOptions?: ResourceOptions): pulumi.Output<import("@pulumi/azure-native/apimanagement/getApiManagementService.js").GetApiManagementServiceResult>;
     /**
      * @summary Method to create a new API Management backend
      * @param id scoped id of the resource

package/dist/src/services/api-management/main.js

@@ -1,4 +1,6 @@
 import { Api, ApiDiagnostic, ApiManagementService, ApiOperation, ApiOperationPolicy, ApiPolicy, Backend, BackendProtocol, Cache, getApiManagementServiceOutput, Logger, LoggerType, NamedValue, Protocol, Subscription, } from '@pulumi/azure-native/apimanagement/index.js';
+import { listDatabaseKeysOutput } from '@pulumi/azure-native/redisenterprise/index.js';
+import * as pulumi from '@pulumi/pulumi';
 /**
  * Provides operations on Azure API Management using Pulumi
  * - A new instance of this class is injected into {@link CommonAzureConstruct} constructor.
@@ -24,7 +26,7 @@ export class AzureApiManagementManager {
      * @param scope scope in which this resource is defined
      * @param props API Management properties
      * @param applicationInsightsKey Optional Application Insights instrumentation key for logging
-     * @param externalRedisCache Optional external Redis cache for API Management caching
+     * @param externalRedisCache Optional external Azure Managed Redis (Enterprise) cluster and database for API Management caching
      * @param resourceOptions Optional settings to control resource behaviour
      * @see [Pulumi Azure Native API Management]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/apimanagementservice/}
      */
@@ -60,16 +62,24 @@ export class AzureApiManagementManager {
                 },
             }, { parent: scope, dependsOn: [apiManagementService] });
         }
-        // Create Redis cache connection if external Redis is provided
+        // Create Redis cache connection if external Azure Managed Redis (Enterprise) is provided
         if (externalRedisCache) {
+            const { cluster, database } = externalRedisCache;
+            const connectionString = pulumi
+                .all([cluster.hostName, cluster.name, database.name])
+                .apply(([hostName, clusterName, databaseName]) => listDatabaseKeysOutput({
+                clusterName,
+                databaseName,
+                resourceGroupName,
+            }).apply(keys => `${hostName}:10000,password=${keys.primaryKey},ssl=True,abortConnect=False`));
             new Cache(`${id}-am-redis-cache`, {
                 cacheId: scope.resourceNameFormatter.format(props.serviceName?.toString(), scope.props.resourceNameOptions?.apiManagementRedisCache),
                 serviceName: apiManagementService.name,
                 resourceGroupName: resourceGroupName,
-                connectionString: externalRedisCache.hostName.apply(hostName => `${hostName}:10000,password=${externalRedisCache.accessKeys.apply(k => k?.primaryKey)},ssl=True,abortConnect=False`),
-                useFromLocation: externalRedisCache.location,
-                resourceId: externalRedisCache.id,
-            }, { parent: scope, dependsOn: apiManagementService });
+                connectionString: connectionString,
+                useFromLocation: cluster.location,
+                resourceId: cluster.id,
+            }, { parent: scope, dependsOn: [apiManagementService, cluster, database] });
         }
         return apiManagementService;
     }

package/dist/src/services/redis/main.d.ts

@@ -1,8 +1,8 @@
 import { ResourceOptions } from '@pulumi/pulumi';
 import { CommonAzureConstruct } from '../../common/index.js';
-import { RedisProps } from './types.js';
+import { ManagedRedisResult, RedisDatabaseProps, RedisEnterpriseClusterProps } from './types.js';
 /**
- * Provides operations on Azure Redis using Pulumi
+ * Provides operations on Azure Managed Redis (Enterprise) using Pulumi
  * - A new instance of this class is injected into {@link CommonAzureConstruct} constructor.
  * - If a custom construct extends {@link CommonAzureConstruct}, an instance is available within the context.
  * @example
@@ -13,7 +13,7 @@ import { RedisProps } from './types.js';
  *   constructor(name: string, props: CommonAzureStackProps) {
  *     super(name, props)
  *     this.props = props
- *     this.redisManager.createManagedRedis('MyManagedRedis', this, props)
+ *     this.redisManager.createManagedRedis('MyManagedRedis', this, { cluster: clusterProps, database: databaseProps })
  *   }
  * }
  * ```
@@ -21,12 +21,13 @@ import { RedisProps } from './types.js';
  */
 export declare class AzureRedisManager {
     /**
-     * @summary Method to create a new managed redis cache
+     * @summary Method to create a new Azure Managed Redis (Enterprise) cluster with a database
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props redis cache properties
+     * @param clusterProps redis enterprise cluster properties
+     * @param databaseProps optional redis database properties (created with defaults if omitted)
      * @param resourceOptions Optional settings to control resource behaviour
-     * @see [Pulumi Azure Native Redis]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/cache/redis/}
+     * @see [Pulumi Azure Native Redis Enterprise]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/redisenterprise/redisenterprise/}
      */
-    createManagedRedis(id: string, scope: CommonAzureConstruct, props: RedisProps, resourceOptions?: ResourceOptions): import("@pulumi/azure-native/redis/redis.js").Redis;
+    createManagedRedis(id: string, scope: CommonAzureConstruct, clusterProps: RedisEnterpriseClusterProps, databaseProps?: Partial<RedisDatabaseProps>, resourceOptions?: ResourceOptions): ManagedRedisResult;
 }

package/dist/src/services/redis/main.js

@@ -1,6 +1,6 @@
-import { Redis, SkuFamily, SkuName } from '@pulumi/azure-native/redis/index.js';
+import { Database, RedisEnterprise, SkuName } from '@pulumi/azure-native/redisenterprise/index.js';
 /**
- * Provides operations on Azure Redis using Pulumi
+ * Provides operations on Azure Managed Redis (Enterprise) using Pulumi
  * - A new instance of this class is injected into {@link CommonAzureConstruct} constructor.
  * - If a custom construct extends {@link CommonAzureConstruct}, an instance is available within the context.
  * @example
@@ -11,7 +11,7 @@ import { Redis, SkuFamily, SkuName } from '@pulumi/azure-native/redis/index.js';
  *   constructor(name: string, props: CommonAzureStackProps) {
  *     super(name, props)
  *     this.props = props
- *     this.redisManager.createManagedRedis('MyManagedRedis', this, props)
+ *     this.redisManager.createManagedRedis('MyManagedRedis', this, { cluster: clusterProps, database: databaseProps })
  *   }
  * }
  * ```
@@ -19,35 +19,41 @@ import { Redis, SkuFamily, SkuName } from '@pulumi/azure-native/redis/index.js';
  */
 export class AzureRedisManager {
     /**
-     * @summary Method to create a new managed redis cache
+     * @summary Method to create a new Azure Managed Redis (Enterprise) cluster with a database
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props redis cache properties
+     * @param clusterProps redis enterprise cluster properties
+     * @param databaseProps optional redis database properties (created with defaults if omitted)
      * @param resourceOptions Optional settings to control resource behaviour
-     * @see [Pulumi Azure Native Redis]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/cache/redis/}
+     * @see [Pulumi Azure Native Redis Enterprise]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/redisenterprise/redisenterprise/}
      */
-    createManagedRedis(id, scope, props, resourceOptions) {
-        if (!props)
+    createManagedRedis(id, scope, clusterProps, databaseProps, resourceOptions) {
+        if (!clusterProps)
             throw new Error(`Props undefined for ${id}`);
         // Get resource group name
         const resourceGroupName = scope.props.resourceGroupName
             ? scope.resourceNameFormatter.format(scope.props.resourceGroupName)
-            : props.resourceGroupName;
+            : clusterProps.resourceGroupName;
         if (!resourceGroupName)
             throw new Error(`Resource group name undefined for ${id}`);
-        return new Redis(`${id}-rc`, {
-            ...props,
-            name: scope.resourceNameFormatter.format(props.name?.toString(), scope.props.resourceNameOptions?.managedRedis),
-            location: props.location ?? scope.props.location,
+        const cluster = new RedisEnterprise(`${id}-rc`, {
+            ...clusterProps,
+            clusterName: scope.resourceNameFormatter.format(clusterProps.clusterName?.toString(), scope.props.resourceNameOptions?.managedRedis),
+            location: clusterProps.location ?? scope.props.location,
             resourceGroupName: resourceGroupName,
-            sku: props.sku ?? {
-                name: SkuName.Basic,
-                family: SkuFamily.C,
-                capacity: 0,
+            sku: clusterProps.sku ?? {
+                name: SkuName.Balanced_B0,
             },
-            tags: props.tags ?? {
+            tags: clusterProps.tags ?? {
                 environment: scope.props.stage,
             },
         }, { parent: scope, ...resourceOptions });
+        const database = new Database(`${id}-db`, {
+            ...databaseProps,
+            clusterName: cluster.name,
+            resourceGroupName: resourceGroupName,
+            databaseName: databaseProps?.databaseName ?? 'default',
+        }, { parent: scope, dependsOn: [cluster], ...resourceOptions });
+        return { cluster, database };
     }
 }

package/dist/src/services/redis/types.d.ts

@@ -1,4 +1,12 @@
-import { RedisArgs } from '@pulumi/azure-native/redis/index.js';
+import { DatabaseArgs, RedisEnterpriseArgs } from '@pulumi/azure-native/redisenterprise/index.js';
 /** @category Interface */
-export interface RedisProps extends RedisArgs {
+export interface RedisEnterpriseClusterProps extends RedisEnterpriseArgs {
+}
+/** @category Interface */
+export interface RedisDatabaseProps extends DatabaseArgs {
+}
+/** @category Interface */
+export interface ManagedRedisResult {
+    cluster: import('@pulumi/azure-native/redisenterprise/index.js').RedisEnterprise;
+    database: import('@pulumi/azure-native/redisenterprise/index.js').Database;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradientedge/cdk-utils-azure",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Azure Pulumi utilities for @gradientedge/cdk-utils",
   "type": "module",
   "main": "dist/src/index.js",