Saravanan666/pypi-org huggingface dataset:
Package: cdk-personalize-datasetgroup
CDK Personalize DatasetGroupResources CreatedCustom Resource Lambda FunctionPersonalize Dataset GroupPersonalize Interactions SchemaPersonalize User-item interaction DatasetPersonalize Event TrackerReturned DataDataset Group Arn:datasetGroupArnEvent Tracker Arn:trackingArnEvent Tracker ID:trackingIDUsage# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826importaws_cdk.coreascdkpersonalize_dataset_group=PersonalizeDatasetGroup(self,"voxi-personalize",dataset_group_name="my-group-name",# Optionalinteractions_schema="{...}")cdk.CfnOutput(self,"personalizeTrackingIDOutput",value=personalize_dataset_group.tracking_iD,description="Tracking ID Output for Amplify or something else")ReferencesAWS PersonalizePersonalize SDKAmplify Personalize
Package: cdk-pgstac
pgSTAC CDK constructPublished Packageshttps://pypi.org/project/cdk-pgstac/https://www.npmjs.com/package/cdk-pgstac/ReleaseVersioning is automatically handled viaConventional CommitsandSemantic Release.Warning: If you rebasemain, you must ensure that the commits referenced by tags point to commits that are within themainbranch. If a commit references a commit that is no longer on themainbranch, Semantic Release will fail to detect the correct version of the project.More information.
Package: cdk-pgstac-dev
pgSTAC CDK constructPublished Packageshttps://pypi.org/project/cdk-seed.pgstac-cdk-construct/https://www.npmjs.com/package/pgstac-cdk-constructReleaseVersioning is automatically handled viaConventional CommitsandSemantic Release.A warning: If you rebasemain, you must ensure that the commits referenced by tags point to commits that are within themainbranch. If a commit references a commit that is no longer on themainbranch, Semantic Release will fail to detect the correct version of the project.More information.
Package: cdk-pigeon.core
PigeonThis is a cheaper version of AWS Synthetics Canary. Head to myblog postto read more about the inspiration for this CDK Construct.Pigeon is meant to be dead simple. It creates a Lambda Function that runs on a schedule and optionally alerts an email if the Lambda fails. Everything created is exposed, so if you want to create an alert different than the default, everything is there for you to do it.Propsschedule: events.SchedulelambdaFunctionProps: lambda.FunctionPropslambdaTargetProps?: targets.LambdaFunctionPropsalertOnFailure?: booleanemailAddress?: stringPropertieslambdaFunction!: lambda.Functionrule!: events.Rulealarm?: cloudwatch.Alarmtopic?: sns.Topic
Package: cdk-pynamodb
AWS CDK Construct for DynamoDB Table from PynamoDB Model.Streamline DynamoDB create and deploy with PynamoDB and AWS CDK.This package provides a construct for creating a DynamoDB table using the AWS CDK and PynamoDB models.
It simplifies the process of creating and deploying DynamoDB tables in your AWS environment.Define your tables in a reusable and predictable way with infrastructure-as-code.InstallationFrom PyPi:$ pip install cdk-pynamodbFrom GitHub:$ pip install git+https://github.com/altoria/cdk-pynamoDB#egg=cdk-pynamodbBasic UsageCreate a model that describes your DynamoDB table.frompynamodb.modelsimportModelclassUserTable(Model):classMeta:host="http://localhost:8000"table_name="user-table"billing_mode=PROVISIONED_BILLING_MODEread_capacity_units=10write_capacity_units=3user_id=UnicodeAttribute(hash_key=True)email=UnicodeAttribute(null=True)Now, you can import and construct model in AWS CDKfromcdk_pynamodbimportPynamoDBTablefrommodelsimportUserTablefromaws_cdkimportStackfromconstructsimportConstructclassDatabase(Stack):def__init__(self,scope:Construct,id_:str):super().__init__(scope,id_)self.table=PynamoDBTable.from_pynamodb_model(self,pynamodb_model=UserTable)
Package: cdk-quicksight-constructs
cdk-quicksight-constructsThis an AWS CDK Custom Constructs repository for AWS QuickSight resources which are currently not supported by Cloudformation. That are currently:DataSourceDataSetThe Repository is build and managed by Projen.Projenis used to manage the Github TypeScript AWS CDK setup. It is developed and maintained from the AWS CDK Community and the favorite framework to manage those AWS CDK project setups.Example# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826users=["martin"]datasource=DataSource(stack,"DataSource",name="cdkdatasource",type="ATHENA",data_source_parameters={"athena_parameters":{"work_group":"ddbworkgroup"}},users=users)DataSet(stack,"DataSet",name="cdkdataset",users=users,physical_table_map={"users":{"custom_sql":{"data_source_arn":datasource.data_source_arn,"name":"users","sql_query":"SELECT primarypractice, dateofbirth FROM\"ddbconnector\".\"martin1\".\"martin1\"WHERE groupid = 'users' AND firstname is not null","columns":[{"name":"primarypractice","type":"STRING"},{"name":"dateofbirth","type":"STRING"}]}},"practices":{"custom_sql":{"data_source_arn":datasource.data_source_arn,"name":"practices","sql_query":"SELECT id, name FROM\"ddbconnector\".\"martin1\".\"martin1\"WHERE groupid = 'medical-practices' AND name is not null","columns":[{"name":"id","type":"STRING"},{"name":"name","type":"STRING"}]}}},logical_table_map={"users":{"alias":"users","source":{"physical_table_id":"users"}},"practices":{"alias":"practices","source":{"physical_table_id":"practices"}},"users-practices":{"alias":"users-practices","source":{"join_instruction":{"left_operand":"users","right_operand":"practices","type":"INNER","on_clause":"primarypractice = id"}},"data_transforms":[{"create_columns_operation":{"columns":[{"column_name":"age","column_id":"age","expression":"dateDiff(parseDate(dateofbirth,\"YYYY-MM-dd'T'HH:mm:ssZ\"),now(),\"YYYY\")"}]}}]}})Main benefits of that are:managing the cdk dependencies and cdk commands likeyarn deploymanaging the node and github config filesa standardized way of how to setup AWS CDK reposTypesThe types for the DataSource and DataSet constructs are generated from the AWS SDK lib and stored in src/sdk/quicksight.ts . Steps to produce the quicksight.ts file:extracting the quicksight.d.ts from node_modules/aws-sdkrenaming it to quicksight.ts and use VS to auto-fix alle issues in itremoving the first and last parts which are not needed for the typesreplacing the properties with readonly notationreplacing the first letter with a small letter to be camel case alignedPlaned Features / Ideas...Helpful Resourceshttps://awscli.amazonaws.com/v2/documentation/api/latest/reference/quicksight/index.htmlAPIhttps://docs.aws.amazon.com/quicksight/latest/APIReference/API_Operations.htmlSDKhttps://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/QuickSight.html#createDataSource-propertyTroubleshooting...Thanks ToThe CDK Community cdk-dev.slack.comProjenproject and the community around it
Package: cdk-rds-dump
cdk-rds-dumpcdk-rds-dump is a Constructs library for AWS CDK that provides the functionality to dump the contents of Amazon RDS, generate it as an SQL file, and store it in Amazon S3.UsageInstall from npm:npmicdk-rds-dumpThen write CDK code as below:import{RdsDump}from'cdk-rds-dump';declareconstrdsCluster:rds.DatabaseCluster;newRdsDump(this,"RdsDump",{dbEngine:DbEngine.MYSQL,rdsCluster:cluster,databaseName:"testDatabase",schedule:events.Schedule.cron({minute:"0",hour:"0"}),lambdaEnv:{ENV_VAR:"value",},createSecretsManagerVPCEndpoint:true,createS3GatewayEndpoint:true,//DBsecretisobtainedfromrdsCluster.secretasdefault.//Ifyouwanttouseadifferentsecret,youcanspecifyitasfollows.//secretId:'secretsmanager-secret-id',});How does it work?This code creates a new RDS cluster and uses the RdsDump Construct to dump the data from that RDS cluster. The dumped data is generated as an SQL file and stored in Amazon S3.For detailed usage and details of the parameters, refer to the API documentation.Why do we need this construct?AWS RDS is a very useful managed RDB service and includes, by default, the ability to create snapshots.
However, in some cases, such as for development reasons, it is easier to handle SQL files dumped from the DB.
Therefore, cdk-rds-dump was created as a construct to easily create SQL files on a regular basis.ContributionContributions to the project are welcome. Submit improvement proposals via pull requests or propose new features.LicenseThis project is licensed under the Apache-2.0 License.
Package: cdk-redisdb
cdk-redisdbAn AWS CDK construct which spins up an Elasticache Replication Group, or a MemoryDB Cluster.Usage (TypeScript/JavaScript)Install via npm:$npmicdk-redisdbAdd an Elasticache Replication Group to your CDK stack:import{RedisDB}from'cdk-redisdb'newRedisDB(this,'redisdb-repl-group',{nodes:1,nodeType:'cache.m6g.large',engineVersion:'6.2',})Add a MemoryDB Cluster to your CDK stack:import{MemoryDB}from'cdk-redisdb'newMemoryDB(this,'memorydb-repl-group',{nodes:1,nodeType:'db.t4g.small',engineVersion:'6.2',})Specify a VPC rather than having a VPC auto-created for you:import{MemoryDB}from'cdk-redisdb'letvpc=newec2.Vpc(this,'Vpc',{subnetConfiguration:[{cidrMask:24,name:'public1',subnetType:ec2.SubnetType.PUBLIC,},{cidrMask:24,name:'isolated1',subnetType:ec2.SubnetType.PRIVATE_ISOLATED,},],})newRedisDB(this,'redis-use-existing-vpc',{existingVpc:vpc,})Add 2 replicas per node, and add shards to cluster when memory exceeds 60%.import{RedisDB}from'cdk-redisdb'newRedisDB(this,'redisdb-repl-group',{nodes:1,replicas:2,//2replicaspernodenodeType:'cache.m6g.large',memoryAutoscalingTarget:60,//nodesCpuAutoscalingTarget})import{RedisDB}from'cdk-redisdb'letvpc=newec2.Vpc(this,'Vpc',{subnetConfiguration:[{cidrMask:24,name:'public1',subnetType:ec2.SubnetType.PUBLIC,},{cidrMask:24,name:'isolated1',subnetType:ec2.SubnetType.PRIVATE,},],})constecSecurityGroup=newec2.SecurityGroup(this,'elasticache-sg',{vpc:vpc,description:'SecurityGroup associated with the ElastiCache Redis Cluster',allowAllOutbound:false,});newRedisDB(this,'redisdb-repl-group',{nodes:1,nodeType:'cache.m6g.large',nodesCpuAutoscalingTarget:50,existingVpc:vpc,existingSecurityGroup:ecSecurityGroup,})Features in progress:MemoryDB ACLs (commented out to avoid default bad practices, read comments to understand the CloudFormation)Features to come:Replication Groups with cluster mode disabled (for those using multiple databases)Improved API - sane choice of props
Package: cdk-s3bucket
cdk-s3bucketCreate a S3 Bucket that can be deleted completely.WhySometime we just do some lab , create a S3 Bucket.
Want to destroy resource , after Lab finished.
But We forget delete Object in S3 Bucket first , so destroy will fail.cdk-s3bucketcan help delete object when cdk destroy , just addremovalPolicy: RemovalPolicy.DESTROYproperty .You never have to delete objects yourself, and the usage is almost the same as the native @aws-cdk/aws-s3.BucketNow Try It !!!Sample# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826fromaws_cdk.coreimportApp,Stack,CfnOutput,RemovalPolicyfromcdk_s3bucketimportBucket# Create a S3 , add props "removalPolicy: RemovalPolicy.DESTROY".bucket=Bucket(stack,"Bucket",removal_policy=RemovalPolicy.DESTROY)# Get S3 Resource via bucket.s3Bucket ...CfnOutput(stack,"BucketName",value=bucket.s3_bucket.bucket_name)To deploycdkdeploy--require-approvalneverTo destroycdkdestroy-f
Package: cdk-s3-bucketreplication
CDK Construct for S3 Bucket ReplicationA CDK Construct for S3 Bucket Replication.  Can handle cross-account replication.  Make sure the source and destination buckets have versioning enabled.const sourceBucket = new Bucket(this, 'SourceBucket', {
  versioned: true,
});
const destinationBucket = new Bucket(this, 'DestinationBucket', {
  versioned: true,
});

new BucketReplication(this, 'BucketReplication', {
  sourceBucket,
  destinationBucket,
  replicationDestinationProperties: {
    storageClass: ReplicationDestinationStorageClass.STANDARD_IA,
  },
});
Package: cdk-secret-manager-wrapper-layer
cdk-secret-manager-wrapper-layerthat Lambda layer uses a wrapper script to fetch information from Secrets Manager and create environmental variables.idea fromsourceExampleimport{App,Stack,CfnOutput,Duration}from'aws-cdk-lib';import{Effect,PolicyStatement}from'aws-cdk-lib/aws-iam';import{Function,Runtime,Code,FunctionUrlAuthType}from'aws-cdk-lib/aws-lambda';import{CfnSecret}from'aws-cdk-lib/aws-secretsmanager';import{SecretManagerWrapperLayer}from'cdk-secret-manager-wrapper-layer';constenv={region:process.env.CDK_DEFAULT_REGION,account:process.env.CDK_DEFAULT_ACCOUNT,};constapp=newApp();conststack=newStack(app,'testing-stack',{env});/***ExamplecreateanSecretfortesting.*/constsecret=newCfnSecret(stack,'Mysecret',{secretString:JSON.stringify({KEY1:'VALUE1',KEY2:'VALUE2',KEY3:'VALUE3',}),});constlayer=newSecretManagerWrapperLayer(stack,'SecretManagerWrapperLayer');constlambda=newFunction(stack,'fn',{runtime:Runtime.PYTHON_3_9,code:Code.fromInline(`importosdefhander(events,contexts):env={}env['KEY1']=os.environ.get('KEY1','Not Found')env['KEY2']=os.environ.get('KEY2','Not Found')env['KEY3']=os.environ.get('KEY3','Not Found')returnenv`),handler:'index.hander',layers:[layer],timeout:Duration.minutes(1),/***youneedtodefinethis4environmentvarious.*/environment:{AWS_LAMBDA_EXEC_WRAPPER:'/opt/get-secrets-layer',SECRET_REGION:stack.region,SECRET_ARN:secret.ref,API_TIMEOUT:'5000',},});/***AddPermissionforlambdagetsecretvaluefromsecretmanager.*/lambda.role!.addToPrincipalPolicy(newPolicyStatement({effect:Effect.ALLOW,actions:['secretsmanager:GetSecretValue'],//Alsoyoucanusefindfromcontext.resources:[secret.ref],}),);/***ForTesting.*/constFnUrl=lambda.addFunctionUrl({authType:FunctionUrlAuthType.NONE,});newCfnOutput(stack,'FnUrl',{value:FnUrl.url,});Testing# ex: curl https://sdfghjklertyuioxcvbnmghj.lambda-url.us-east-1.on.aws/curl${FnUrl}{"KEY2":"VALUE2","KEY1":"VALUE1","KEY3":"VALUE3"}
Package: cdk-secrets
DEPRECATED - CDK SecretsThis project isdeprecated. The original goal of this construct was to provide an API for creating EC2 Key Pairs. The custom resource provider I used had much more functionality. It turned out this additional functionality was never needed and creating EC2 Key Pairs was overly complicated.To create EC2 Key Pairs you now can use my new construct:cdk-ec2-key-pairAWS CDKconstruct to manage secrets. It makes use of a custom resource provider frombinxio/cfn-secret-provider.This package is written in TypeScript and made available viaJSIIto all other supported languages. Package are available on:npmPyPINuGetGitHub packages for JavaThe secret provider can create RSA keys, DSA keys, EC2 key-pairs, IAM user passwords and access keys and generally secrets stored in parameter store or secret store.All this functionality is provided by thebinxio/cfn-secret-providercustom resource.When it comes to security, you should not trust anyone. By default the secret provider uses the lambda function stored ats3://binxio-public-${AWS_REGION}/lambdas/cfn-secret-provider-1.0.0.zip. You might want to download this file, review its contents and store it in your own bucket or along with your code. You then can create the lambda function from that zip file instead like so:# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826code=lambda.Code.from_asset(path.join(__dirname,"../cfn-secret-provider-1.0.0.zip"))secret_provider=secret.Provider(self,"SecretProvider",code=code)ExamplesThere is an example application in./exampleshowing how to create a new EC2 key pair.
Package: cdk-serverless-airflow
CDK Serverless AirflowCDK construct library that allows you to createApache Airflowon AWS in TypeScript or PythonArchitectureSample# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826importaws_cdk.coreascdkimportcdk_serverless_airflowasairflowapp=cdk.App()env={"region":process.env.CDK_DEFAULT_REGION,"account":process.env.CDK_DEFAULT_ACCOUNT}stack=cdk.Stack(app,"airflow-stack",env=env)airflow.Airflow(stack,"Airflow")Airflow DashboardDefault Credential: user/bitnamiAWS China RegionsAWS China regionscn-north-1andcn-northwest-1are supported by this Library.LicenseThis project is licensed under the Apache-2.0 License.
Package: cdk-simple-serverless
cdk-simple-serverlessTiny serverless constructs wih all optional construct properties to keep it as simple as possible for demo out of the box.InstallUse the npm dist tag to opt in CDKv1 or CDKv2://forCDKv2
npminstallcdk-simple-serverless
or
npminstallcdk-simple-serverless@latest

//forCDKv1
npminstallcdk-simple-serverless@cdkv1HelloFunctionAWS Lambda function that returns"Hello CDK!"only.import{HelloFunction}from'cdk-simple-serverless'newHelloFunction(stack,'Function')HelloRestApiServiceAmazon API Gateway REST API service that returns"Hello CDK!"only in the HTTP response.import{HelloRestApiService}from'cdk-simple-serverless'newHelloRestApiService(stack,'Service')
Package: cdk-slack-chatbot
cdk-slack-chatbotA CDK construct which creates an SNS AWS ChatBot (Slack) integration for CloudWatch alarms, AWS Config rules, ...More information on how to use this construct can be foundhere.ArchitectureExampleIn this example we create a CloudWatch alarm which integrates with our construct.import*ascdkfrom'aws-cdk-lib';import*ascloudwatchfrom'aws-cdk-lib/aws-cloudwatch';import*ascloudwatch_actionsfrom'aws-cdk-lib/aws-cloudwatch-actions';import*assqsfrom'aws-cdk-lib/aws-sqs';import{CdkSlackChatBot}from'cdk-slack-chatbot';exportclassCdkDemoStackextendscdk.Stack{constructor(scope:cdk.App,id:string,props?:cdk.StackProps){super(scope,id,props);constqueue=newsqs.Queue(this,'HelloCdkQueue',{visibilityTimeout:cdk.Duration.seconds(300)});constqMetric=queue.metric('ApproximateNumberOfMessagesVisible');constalarm=newcloudwatch.Alarm(this,'Alarm',{metric:qMetric,threshold:100,evaluationPeriods:3,datapointsToAlarm:2});constslackIntegration=newCdkSlackChatBot(this,'SlackIntegration',{topicName:'slack-alarm',slackChannelId:'xxx',slackWorkSpaceId:'yyy',slackChannelConfigName:'slack',});alarm.addAlarmAction(newcloudwatch_actions.SnsAction(slackIntegration.topic));}}Test Alarm:$ aws cloudwatch set-alarm-state --alarm-name "xxx" --state-value ALARM --state-reason "testing purposes"
Package: cdk-sns-notify
cdk-sns-notifyA CDK construct library to send line notify or discord webhookSampleimport*assnsfrom"@aws-cdk/aws-sns";import*ascloudwatchfrom"@aws-cdk/aws-cloudwatch";import*ascw_actionsfrom"@aws-cdk/aws-cloudwatch-actions";import{SnsNotify}from"cdk-sns-notify";consttopic=newsns.Topic(stack,"Topic");constmetric=newcloudwatch.Metric({namespace:"AWS/EC2",metricName:"CPUUtilization",dimensions:{InstanceId:instance.instanceId,},period:cdk.Duration.minutes(1),});constalarm=newcloudwatch.Alarm(stack,"Alarm",{metric,threshold:5,evaluationPeriods:1,});alarm.addAlarmAction(newcw_actions.SnsAction(topic));constsnsLineNotify=newSnsNotify(stack,"sns-line-notify",{lineNotifyToken:"lineNotifyToken",});topic.addSubscription(snsLineNotify.lambdaSubscription);Deploycdkdeploy
Package: cdk-soca
Welcome tocdk-socacdk-socais an AWS CDK construct library that allows you to create theScale-Out Computing on AWSwith AWS CDK inTypeScriptorPython.Sample# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826importcdk_socaassoca# create the CDK applicationapp=App()# create the stack in the CDK appstack=Stack(app,"soca-testing-stack")# create the workload in the CDK stacksoca.Workload(stack,"Workload")That's all!
Package: cdk-sqlserver-seeder
cdk-sqlserver-seederA simple CDK seeder for SQL Server RDS databases.When you create an RDS SQL Server instance using CloudFormation template, there is no way to provide initial
schema definition as part of CloudFormation stack deployment. Custom schema deployment scripts can be executed
only after the database deployment is complete.cdk-sqlserver-seederlibrary is aAWS CDKconstruct that provides a way to automate
this process and eliminate manual steps involved in the process of preparing new RDS SQL Server environment by
executing custom SQL scripts on RDS SQL Server instance creation/deletion.The construct relies onInvoke-SqlCmdcmdlet
to run the scripts and provides a way to handle transient errors during stack provisioning.Usage# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826importaws_cdk.coreascdkimportaws_cdk.aws_ec2asec2importaws_cdk.aws_rdsasrdsfromcdk_sqlserver_seederimportSqlServerSeederclassDatabaseStack(cdk.Stack):def__init__(self,scope,id,*,description=None,env=None,stackName=None,tags=None,synthesizer=None,terminationProtection=None):super().__init__(scope,id,description=description,env=env,stackName=stackName,tags=tags,synthesizer=synthesizer,terminationProtection=terminationProtection)sql_server=rds.DatabaseInstance(self,"Instance",engine=rds.DatabaseInstanceEngine.SQL_SERVER_WEB)seeder=SqlServerSeeder(self,"SqlSeeder",database=sql_server,port=1433,vpc=vpc,create_script_path="./SQL/v1.0.0.sql",# script to be executed on resource creationdelete_script_path="./SQL/cleanup.sql")Configuration propertiesSqlServerSeeder construct accepts the following configuration properties:ParameterRequiredDefaultDescriptionvpcyesVPC for Lambda function deploymentdatabaseyesRDS SQL Server database instancecreateScriptPathyesSQL scripts to run on resource creationdeleteScriptPathnoSQL script to run on resource deletionportno1433RSD SQL Server database portmemorySizeno512Lambda function memory sizeignoreSqlErrorsnofalseWhether to ignore SQL error or notArchitecturecdk-sqlserver-seederdeploys a custom resource backed by PowerShell lambda to connect to SQL Server instance. Lambda function is deployed in private subnets of your VPC where RDS instance resides.Lambda function retrieves database credentials fromAWS Secrets Managerand uses them to construct connection string to the database.SQL scripts are uploaded into S3 bucket during CDK application deployment.
Lambda function downloads these scripts during execution.Security considerationsLambda function has the following permissions:Managed policiesAWSLambdaBasicExecutionRolefor CloudWatch logsAWSLambdaVPCAccessExecutionRolefor VPC accessInline policysecretsmanager:GetSecretValuefor RDS credentials secrets3:GetObject*,s3:GetBucket*,s3:List*for S3 bucket with SQL scriptsAcknowledgementsThe whole project inspired byaws-cdk-dynamodb-seeder.
I though it would be very helpful to have a similar way to seed initial schema to more traditional SQL Server databases.
Package: cdk-sqs-monitored
AWS CDK SQS Construct with alarms and dead letter queueWhat it doesCreates:two queues, one main and one dead letter. Dead letter has added suffix "--dead-letter" to name passed inqueueSettings.queueNameSNS topic with target configured to email fromalarmEmailparameteralarms for both queuesfor main queue: message age, passed asalarmWhenMessageOlderThanSecondsparameterfor dead letter: alarm triggered if there is any messageAlarms are configured to be sent as fast as possible. Note that SQS report values to CloudWatch every 5 mins.Installationnpminstall--savecdk-sqs-monitoredUsageMinimal config:import*ascdkfrom'@aws-cdk/core';import*aslibfrom'cdk-sqs-monitored';constapp=newcdk.App();exportclassSampleAppStackextendscdk.Stack{constructor(scope:cdk.App,id:string,props?:cdk.StackProps){super(scope,id,props);newlib.MonitoredQueue(this,'q1',{alarmEmail:'your-email@test.com',alarmWhenMessageOlderThanSeconds:300,maxReceiveCount:3,queueSettings:{queueName:'test-queue',}})}}newSampleAppStack(app,'SampleappStack');queueSettings parameter expects standard @aws-cdk/aws-sqsQueuePropsobjectModyfying and PRYou're always welcome to create PR, but it might be best solution for you to just fork the repository and apply
the changes in your repo.LicenseMIT
Package: cdk-ssm-parameter-store
cdk-ssm-parameter-storeAWS CDK construct that allows you to get the latestVersionof the AWS SSM Parameters.Sample# Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826importcdk_ssm_parameter_storeasparamstack=Stack(app,"testing-stack",env=env)p=param.Provider(stack,"ParameterProvider")foo_version=p.get("Foo").get_att_string("Version")bar_version=p.get("Bar").get_att_string("Version")CfnOutput(stack,"FooVersion",value=foo_version)CfnOutput(stack,"BarVersion",value=bar_version)