def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) prj_name = self.node.try_get_context("project_name") env_name = self.node.try_get_context("env") api_gateway = apigw.RestApi(self,'restapi', endpoint_types=[apigw.EndpointType.REGIONAL], minimum_compression_size=1024, binary_media_types=["multipart/form-data"], rest_api_name=prj_name+'-apigateway' ) apigw.Method(self,'method1', http_method="POST", resource=api_gateway ) #TODO #domain name
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here handler = _lambda.Function( self, "demo_func", runtime=_lambda.Runtime.PYTHON_3_7, handler="demo_func.handler", timeout=Duration.minutes(1), # pylint: disable=E1120 code=_lambda.Code.asset("lambda_code/demo_func"), # pylint: disable=E1120 ) api_gw = _apigw.RestApi(self, "ApiGatewayForSlack", rest_api_name="gw_for_slack") exam_entity = api_gw.root.add_resource("test") exam_entity_lambda_integration = _apigw.LambdaIntegration( handler, proxy=False, integration_responses=[{ "statusCode": "200" }], ) exam_entity.add_method( "GET", exam_entity_lambda_integration, method_responses=[{ "statusCode": "200" }], )
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # create s3 bucket bucket = s3.Bucket(self, "cdkdemobucket", public_read_access=True, bucket_name="cdkdemobucket") # upload local file to s3 bucket deploy = s3deploy.BucketDeployment( self, 'DeployLocal', sources=[s3deploy.Source.asset('resources/s3')], destination_bucket=bucket) # create lambda function handler = lambda_.Function( self, "toppage", runtime=lambda_.Runtime.PYTHON_3_7, code=lambda_.Code.asset("resources/webapp/artifact"), handler="webapp.main", environment=dict(BUCKET=bucket.bucket_name)) bucket.grant_read_write(handler) #api gateway api = apigateway.RestApi(self, "demo page", rest_api_name="demo page") get_top_page = apigateway.LambdaIntegration( handler, request_templates={"application/json": '{ "statusCode": "200" }'}) api.root.add_method("GET", get_top_page)
def _create_rest_api(self, api_log_group, gw, stage): return _api_gw.RestApi( self, gw["gw_name"], rest_api_name=gw["gw_name"], deploy_options={ "description": gw["gw_stage_description"], "logging_level": LOG_INFO, "tracing_enabled": True, "stage_name": stage, "access_log_destination": LogGroupLogDestination(api_log_group), "access_log_format": AccessLogFormat.json_with_standard_fields(caller=False, http_method=True, ip=True, protocol=True, request_time=True, resource_path=True, response_length=True, status=True, user=True), "metrics_enabled": True, }, endpoint_configuration={"types": [EndpointType.REGIONAL]}, deploy=True, cloud_watch_role=True, description=gw["gw_description"], )
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # lambda lambda_ = aws_lambda.Function( self, "ApiLambdaIntegrationLambda", code=aws_lambda.Code.asset("lambdas/api_lambda_integration"), runtime=aws_lambda.Runtime.PYTHON_3_8, handler="lambda_function.lambda_handler", ) # API Gateway api = aws_apigateway.RestApi( self, "ApiLambdaIntegrationApiGateway", deploy_options=aws_apigateway.StageOptions(stage_name="hogehoge")) hoge_resources = api.root.add_resource("hoge") hoge_resources.add_method( "GET", aws_apigateway.LambdaIntegration(lambda_), request_parameters={ # クエリ文字列(URLパラメータ)の明示的に宣言 "method.request.querystring.hoge": True, # 必須 "method.request.querystring.hogeOption": False, # 必須ではない }, # 下記設定を入れないと必須フラグは動作しない request_validator=api.add_request_validator( "ApiLambdaIntegrationValidator", validate_request_parameters=True), )
def __init__(self, scope: core.Construct, id: str): super().__init__(scope, id) '''wallet_table = dynamodb.table('WalletDetail') transaction_table = dynamodb.table('TransactionDetail')''' create_trx_handler = lambda_.Function( "Transaction", "TrxCreateHandler", function_name="TransactionCreate", runtime=lambda_.Runtime.PYTHON_3_7, code=lambda_.Code.asset("resources"), handler="create.handler", environment=dict(WALLET_TABLE="WalletDetail", TRANSACTION_TABLE="TransactionDetail")) '''transaction_table.grant_read_write_data(create_trx_handler) wallet_table.grant_read_write_data(create_trx_handler)''' api = apigateway.RestApi(self, "Transaction-api", rest_api_name="Wallet Service", description="This service serves Wallets.") post_integration = apigateway.LambdaIntegration( create_trx_handler, request_templates={"application/json": '{ "statusCode": "200" }'}) api.root.add_method("POST", post_integration)
def __configure_gateway(self) -> None: self.gateway = a.RestApi(self, 'PortfolioMgmt') # Create kinesis integration integration_role = iam.Role( self, 'KinesisIntegrationRole', assumed_by=iam.ServicePrincipal('apigateway.amazonaws.com')) self.updates_stream.grant_write(integration_role) updates = self.gateway.root.add_resource('updates') updates.add_method(http_method='POST', authorization_type=a.AuthorizationType.IAM, integration=a.AwsIntegration( service='kinesis', action='PutRecord', subdomain=self.updates_stream.stream_name, options=a.IntegrationOptions( credentials_role=integration_role))) pmapi = self.gateway.root.add_resource('pmapi') pmapi.add_proxy( any_method=True, default_integration=a.LambdaIntegration(handler=PythonLambda( self, 'PortfolioMgmtAPI', build_prefix='artifacts/FinSurf-PortfolioMgmt-API', handler='handler.app', subnet_group_name='PortfolioMgmt', context=self.context, securityGroups=[self.security_group]).function))
def __init__(self, scope: core.Construct, id: str): super().__init__(scope, id) bucket = s3.Bucket(self, "WidgetStore") handler = lambda_.Function( self, "WidgetHandler", runtime=lambda_.Runtime.PYTHON_3_7, code=lambda_.Code.asset("resources"), handler="widgets.handler", environment=dict(BUCKET=bucket.bucket_name), ) bucket.grant_read_write(handler) api = apigateway.RestApi( self, "widgets-api", rest_api_name="Widget Service", description="This service serves widgets.", ) get_widgets_integration = apigateway.LambdaIntegration( handler, request_templates={"application/json": '{"statusCode":"200"}'}) api.root.add_method("GET", get_widgets_integration) widget = api.root.add_resource("widget") post_widget_integration = apigateway.LambdaIntegration(handler) get_widget_integration = apigateway.LambdaIntegration(handler) delete_widget_integration = apigateway.LambdaIntegration(handler) widget.add_method("POST", post_widget_integration) widget.add_method("GET", get_widget_integration) widget.add_method("DELETE", delete_widget_integration)
def create_api(self, discord_app_handler: Function): api = aws_apigateway.RestApi(self, "eternal-guesses-api", rest_api_name="Eternal Guesses API") discord_app_integration = aws_apigateway.LambdaIntegration( discord_app_handler) discord_resource = api.root.add_resource("discord") discord_resource.add_method("POST", discord_app_integration)
def __init__(self, scope: core.Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) # The code that defines your stack goes here # DynamoDB定義 dynamo_table = dynamo.Table( self, "schedule", partition_key={ "name": "id", "type": dynamo.AttributeType.STRING, }, table_name="schedule", removal_policy=core.RemovalPolicy. DESTROY, # NOT recommended for production code ) # GET Request get_schedule_lambda = lam.Function( self, "get-schedule-function", code=lam.Code.from_asset("lambda"), handler="get_schedule.lambda_handler", runtime=lam.Runtime.PYTHON_3_8, environment={ "TABLE_NAME": dynamo_table.table_name, "PRIMARY_KEY": "id", }, ) dynamo_table.grant_read_data(get_schedule_lambda) # POST Request set_schedule_lambda = lam.Function( self, "set-schedule-function", code=lam.Code.from_asset("lambda"), handler="set_schedule.lambda_handler", runtime=lam.Runtime.PYTHON_3_8, environment={ "TABLE_NAME": dynamo_table.table_name, "PRIMARY_KEY": "id", }, ) dynamo_table.grant_read_write_data(set_schedule_lambda) api = apigateway.RestApi(self, "scheduler-api-template", rest_api_name="scheduler-api-template") schedule = api.root.add_resource("schedule") schedule.add_resource("{id}").add_method( "GET", apigateway.LambdaIntegration(get_schedule_lambda)) # schedule.add_method("GET", apigateway.LambdaIntegration(get_schedule_lambda)) schedule.add_method("POST", apigateway.LambdaIntegration(set_schedule_lambda)) add_cors_options(schedule)
def rest_api(self, event_streams, event_replayer): rest_api = _api_gtw.RestApi(self, "{}RestApi".format(self.stack_id)) rest_api.add_usage_plan("RestApiUsagePlan", api_key=_api_gtw.ApiKey(self, "TestApiKey"), api_stages=[ _api_gtw.UsagePlanPerApiStage( api=rest_api, stage=rest_api.deployment_stage) ]) api_role = _iam.Role( self, "RestApiRole", assumed_by=_iam.ServicePrincipal('apigateway.amazonaws.com')) api_role.add_to_policy( _iam.PolicyStatement( actions=['firehose:PutRecord'], resources=[stream.attr_arn for stream in event_streams])) for stream in event_streams: stream_resource = rest_api.root.add_resource( path_part=stream.delivery_stream_name.lower(), ) stream_resource.add_method( 'POST', api_key_required=True, integration=_api_gtw.Integration( type=_api_gtw.IntegrationType.AWS, uri= "arn:aws:apigateway:eu-west-1:firehose:action/PutRecord", integration_http_method='POST', options=_api_gtw.IntegrationOptions( credentials_role=api_role, passthrough_behavior=_api_gtw.PassthroughBehavior. NEVER, request_parameters={ 'integration.request.header.Content-Type': "'application/x-amz-json-1.1'" }, request_templates={ 'application/json': json.dumps({ "DeliveryStreamName": stream.delivery_stream_name, "Record": { "Data": "$util.base64Encode($input.body)" } }) }, integration_responses=[ _api_gtw.IntegrationResponse(status_code="200") ])), method_responses=[_api_gtw.MethodResponse(status_code="200")]) replay = stream_resource.add_resource(path_part='replay') replay.add_method( http_method='POST', integration=_api_gtw.LambdaIntegration(event_replayer), method_responses=[ _api_gtw.MethodResponse(status_code="202"), _api_gtw.MethodResponse(status_code="400") ])
def __init__(self, scope: core.Construct, id: str, user_pool_arn: str) -> None: super().__init__(scope, id) core.CfnOutput(self, id="StackName", value=get_stack_name()) self.service_role = iam.Role( self, "KesherServiceRole", assumed_by=iam.ServicePrincipal("lambda.amazonaws.com"), inline_policies={ "KesherServicePolicy": iam.PolicyDocument(statements=[ iam.PolicyStatement(actions=[ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], resources=["arn:aws:logs:*:*:*"], effect=iam.Effect.ALLOW) ]) }) EmailServices(scope=self, id="Email", lambda_role=self.service_role) role_output = core.CfnOutput(self, id="KesherServiceRoleArn", value=self.service_role.role_arn) role_output.override_logical_id("KesherServiceRoleArn") self.table = aws_dynamodb.Table( self, 'kesher-employees', partition_key=aws_dynamodb.Attribute( name="id", type=aws_dynamodb.AttributeType.STRING), billing_mode=aws_dynamodb.BillingMode.PAY_PER_REQUEST, removal_policy=core.RemovalPolicy.RETAIN) self.table.grant_read_write_data(self.service_role) self.rest_api: apigw.LambdaRestApi = apigw.RestApi( self, "kesher-rest-api", rest_api_name="kesher Rest API", description="This service handles kesher's APIs..") endpoint_output = core.CfnOutput(self, id="KesherApiGw", value=self.rest_api.url) endpoint_output.override_logical_id("KesherApiGw") self.api_authorizer: apigw.CfnAuthorizer = self.__create_api_authorizer( user_pool_arn=user_pool_arn, api=self.rest_api) self.api_resource: apigw.Resource = self.rest_api.root.add_resource( "api") self._environment = {"KESHER_USER_POOL_ARN": user_pool_arn} self._add_children_api() self._add_report_categories_api() self._add_user_profile_api()
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) api_log_group = cwlogs.LogGroup(self, "HelloWorldAPILogs") # Create the api gateway for this lambda set self.target_api = apigw.RestApi( self, 'HelloWorldAPI', rest_api_name='HelloWorld', endpoint_types=[apigw.EndpointType.REGIONAL], deploy_options={ "access_log_destination": apigw.LogGroupLogDestination(api_log_group), "access_log_format": apigw.AccessLogFormat.clf(), "method_options": { "/*/*": { # This special path applies to all resource paths and all HTTP methods "throttling_rate_limit": 100, "throttling_burst_limit": 200 } } }) hello_world = py_lambda.PythonFunction( self, "HelloWorld", entry='thewafapigateway/lambda_fns', index='helloworld.py', handler='lambda_handler', description='Helloworld', timeout=core.Duration.seconds(60)) entity = self.target_api.root.add_resource('helloworld') this_lambda_integration = apigw.LambdaIntegration( hello_world, proxy=False, integration_responses=[{ 'statusCode': '200', 'responseParameters': { 'method.response.header.Access-Control-Allow-Origin': "'*'", } }]) method = entity.add_method( 'GET', this_lambda_integration, method_responses=[{ 'statusCode': '200', 'responseParameters': { 'method.response.header.Access-Control-Allow-Origin': True, } }]) self.resource_arn = f"arn:aws:apigateway:ap-southeast-2::/restapis/{self.target_api.rest_api_id}/stages/{self.target_api.deployment_stage.stage_name}"
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # S3 Bucket to store files myBucket = aws_s3.Bucket(self, "S3Bucket", bucket_name="new-app-bucket-example" ) # Lambda triggered periodically myScheduledLambda = _lambda.Function( self, "scheduled_lambda", description="Lambda that will be called according to a schedule", function_name="scheduledLambda", runtime=_lambda.Runtime.PYTHON_3_7, handler="scheduled_lambda.handler", code=_lambda.Code.from_asset("../functions"), memory_size=128, # Memory in mb retry_attempts=2, environment={"S3_BUCKET": myBucket.bucket_name} ) # Give Lambda access to S3 bucket myBucket.grant_read(myScheduledLambda) myBucket.grant_put(myScheduledLambda) # Create cron Rule for Lambda myScheduledLambdaEvent = aws_events.Rule( self, "scheduled_lambda_event", schedule=aws_events.Schedule.rate(core.Duration.minutes(2)), enabled=True, targets=[aws_events_targets.LambdaFunction(handler=myScheduledLambda)] ) # API Gateway Proxy Lambda definition myEndpointLambda = _lambda.Function( self, "endpoint_lambda", description="Lambda Proxy with Api Gateway", function_name="endpointLambda", runtime=_lambda.Runtime.PYTHON_3_7, handler="endpoint_lambda.handler", code=_lambda.Code.from_asset("../functions"), memory_size=128, # Memory in mb retry_attempts=2, environment={"S3_BUCKET": myBucket.bucket_name} ) # Give lambda access to S3 Bucket myBucket.grant_read(myEndpointLambda) myBucket.grant_put(myEndpointLambda) # Define API Gateway endpoints api = aws_apigateway.RestApi(self, "ApiEndpoint") api.root.resource_for_path("/test").add_method("GET", aws_apigateway.LambdaIntegration(handler=myEndpointLambda))
def __init__(self, scope: core.Construct, id: str, stack_prefix: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # IAM Roles lambda_role = _iam.Role( self, id='{}-lambda-role'.format(stack_prefix), assumed_by=_iam.ServicePrincipal('lambda.amazonaws.com')) cw_policy_statement = _iam.PolicyStatement(effect=_iam.Effect.ALLOW) cw_policy_statement.add_actions("logs:CreateLogGroup") cw_policy_statement.add_actions("logs:CreateLogStream") cw_policy_statement.add_actions("logs:PutLogEvents") cw_policy_statement.add_actions("logs:DescribeLogStreams") cw_policy_statement.add_resources("*") lambda_role.add_to_policy(cw_policy_statement) # AWS Lambda Functions fnLambda_secureAPI = _lambda.Function( self, "{}-function-secureApi".format(stack_prefix), code=_lambda.AssetCode("../lambda-functions/secure-api"), handler="app.handler", timeout=core.Duration.seconds(60), role=lambda_role, runtime=_lambda.Runtime.PYTHON_3_8) fnLambda_authorizer = _lambda.Function( self, "{}-function-tokenAuthorizer".format(stack_prefix), code=_lambda.AssetCode("../lambda-functions/token-authorizer"), handler="app.handler", timeout=core.Duration.seconds(60), role=lambda_role, runtime=_lambda.Runtime.PYTHON_3_8) api = _ag.RestApi( self, id="{}-api-gateway".format(stack_prefix), ) api_authorizer = _ag.TokenAuthorizer( self, id="{}-authorizer".format(stack_prefix), handler=fnLambda_authorizer) int_secure_api = _ag.LambdaIntegration(fnLambda_secureAPI) res_data = api.root.add_resource('api') res_data.add_method('GET', int_secure_api, authorizer=api_authorizer) core.CfnOutput(self, "{}-output-apiEndpointURL".format(stack_prefix), value=api.url, export_name="{}-apiEndpointURL".format(stack_prefix))
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) self.table_name = 'globaldatatest.global.table' executelambda = aws_lambda.Function( self, id='execute', runtime=aws_lambda.Runtime.PYTHON_3_8, handler='execute.lambda_handler', code=aws_lambda.Code.asset('lambda')) statsLambda = aws_lambda.Function( self, id='stats', runtime=aws_lambda.Runtime.PYTHON_3_8, handler='stats.lambda_handler', code=aws_lambda.Code.asset('lambda')) resetLambda = aws_lambda.Function( self, id='reset', runtime=aws_lambda.Runtime.PYTHON_3_8, handler='reset.lambda_handler', code=aws_lambda.Code.asset('lambda')) my_bucket = s3.Bucket(self, id='s3buckset3', bucket_name='s3mybucket') table = aws_dynamodb.Table(self, 'table3', partition_key={ 'name': 'key', 'type': aws_dynamodb.AttributeType.STRING }, table_name='commands') api = apigateway.RestApi( self, "web-shell-apii", rest_api_name="Web Shell", description="This service serves shell commands.") executeIntegration = apigateway.LambdaIntegration(executelambda) statsIntegration = apigateway.LambdaIntegration(statsLambda) resetIntegration = apigateway.LambdaIntegration(resetLambda) executeResource = api.root.add_resource('execute') executeResource.add_method("POST", executeIntegration, api_key_required=True) statsResource = api.root.add_resource('stats') statsResource.add_method("GET", statsIntegration, api_key_required=True) resetResource = api.root.add_resource('reset') resetResource.add_method("PUT", resetIntegration, api_key_required=True)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) api_log_group = cw_logs.LogGroup(self, "HelloWorldAPILogs") # Create the api gateway for this lambda set self.target_api = api_gw.RestApi( self, 'HelloWorldAPI', rest_api_name='HelloWorld', endpoint_types=[api_gw.EndpointType.REGIONAL], deploy_options=api_gw.StageOptions( access_log_destination=api_gw.LogGroupLogDestination( api_log_group), access_log_format=api_gw.AccessLogFormat.clf(), method_options={ # This special path applies to all resource paths and all HTTP methods "/*/*": api_gw.MethodDeploymentOptions(throttling_rate_limit=100, throttling_burst_limit=200) })) hello_world = _lambda.Function( self, "HelloWorld", runtime=_lambda.Runtime.PYTHON_3_8, handler='helloworld.lambda_handler', code=_lambda.Code.from_asset("lambda_fns"), timeout=core.Duration.seconds(60)) entity = self.target_api.root.add_resource('helloworld') this_lambda_integration = api_gw.LambdaIntegration( hello_world, proxy=False, integration_responses=[ api_gw.IntegrationResponse( status_code='200', response_parameters={ 'method.response.header.Access-Control-Allow-Origin': "'*'" }) ]) entity.add_method( 'GET', this_lambda_integration, method_responses=[ api_gw.MethodResponse( status_code='200', response_parameters={ 'method.response.header.Access-Control-Allow-Origin': True }) ]) self.resource_arn = f"arn:aws:apigateway:{core.Stack.of(self).region}::/restapis/{self.target_api.rest_api_id}/stages/{self.target_api.deployment_stage.stage_name}"
def __init__(self, scope: core.Construct, construct_id: str, processing_bucket, processing_bucket_upload_prefix) -> None: super().__init__(scope, construct_id) # lambda to act as upload API handler lambda_name = 'image-pipeline-s3-url-generator' s3_url_generator_lambda = aws_lambda.Function( self, lambda_name, function_name=lambda_name, runtime=aws_lambda.Runtime.NODEJS_12_X, code=aws_lambda.Code.asset('lambda_functions/get_signed_s3_url'), handler='app.handler', environment={ 'UploadBucket': processing_bucket.bucket_name, 'UploadPrefix': processing_bucket_upload_prefix, }, timeout=core.Duration.minutes(3) ) # write access allows the lambda to generate signed urls processing_bucket.grant_write(s3_url_generator_lambda) # rest api endpoint to pass requests to lambda base_api = aws_apigateway.RestApi(self, 'ImageUpload', rest_api_name='ImageUpload') # we'll send uploads to the `image` prefix, CORS must be allowed image_entity = base_api.root.add_resource( 'images', default_cors_preflight_options=aws_apigateway.CorsOptions( allow_origins=aws_apigateway.Cors.ALL_ORIGINS) ) # hooks the endpoint up to the lambda above image_entity_lambda_integration = aws_apigateway.LambdaIntegration( s3_url_generator_lambda, proxy=False, integration_responses=[{ 'statusCode': '200', 'responseParameters': { 'method.response.header.Access-Control-Allow-Origin': "'*'", } }]) # GET will be used to get presigned url image_entity.add_method( 'GET', image_entity_lambda_integration, method_responses=[{ 'statusCode': '200', 'responseParameters': { 'method.response.header.Access-Control-Allow-Origin': True, } }]) self.api = base_api
def create_and_integrate_apigw(self, queue: sqs.Queue, dashboard_name_prefix: str) -> str: """Creates API Gateway and integrates with SQS queue :param queue: the SQS queue to integrate with :type queue: aws_cdk.aws_sqs.Queue :param dashboard_name_prefix: the dashboard name to use as the API Gateway resource name :type dashboard_name_prefix: str :returns: the url that the webhooks will post to :rtype: str """ webhook_apigw_role = iam.Role( self, 'WebhookAPIRole', role_name='WebhookAPIRole', assumed_by=iam.ServicePrincipal('apigateway.amazonaws.com')) webhook_apigw_role.add_to_policy( iam.PolicyStatement(resources=['*'], actions=['sqs:SendMessage'])) webhook_apigw = apigw.RestApi( self, 'RepositoryStatusMonitorAPI', rest_api_name='RepositoryStatusMonitorAPI') webhook_apigw_resource = webhook_apigw.root.add_resource( dashboard_name_prefix) apigw_integration_response = apigw.IntegrationResponse( status_code='200', response_templates={'application/json': ""}) apigw_integration_options = apigw.IntegrationOptions( credentials_role=webhook_apigw_role, integration_responses=[apigw_integration_response], request_templates={ 'application/json': 'Action=SendMessage&MessageBody=$input.body' }, passthrough_behavior=apigw.PassthroughBehavior.NEVER, request_parameters={ 'integration.request.header.Content-Type': "'application/x-www-form-urlencoded'" }) webhook_apigw_resource_sqs_integration = apigw.AwsIntegration( service='sqs', integration_http_method='POST', path='{}/{}'.format(core.Aws.ACCOUNT_ID, queue.queue_name), options=apigw_integration_options) webhook_apigw_resource.add_method( 'POST', webhook_apigw_resource_sqs_integration, method_responses=[apigw.MethodResponse(status_code='200')]) path = '/' + dashboard_name_prefix return webhook_apigw.url_for_path(path)
def __init__(self, scope: core.Construct, id: str, common_stack: CommonStack, **kwargs) -> None: super().__init__(scope, id, **kwargs) self._supported_in_region = self.is_service_supported_in_region() # Create API api = apigateway.RestApi(self, "testApi") # Generate a random API key, add it to the underlying CloudFormation # resource of the Construct so that we can use it in our tests. api_key_value = self.random_hex(20) api_key = api.add_api_key("testKey") cfn_api_key = api_key.node.default_child cfn_api_key.add_property_override("Value", api_key_value) # Create Usage Plan and add it to the API plan = api.add_usage_plan("usagePlan", api_key=api_key) plan.add_api_stage(stage=api.deployment_stage) # Create resources in API echo = api.root.add_resource("echo") echo_post = echo.add_resource("post") auth = api.root.add_resource("auth") apikey = api.root.add_resource("apikey") # Wire up methods get_url = self.HTTPBIN_URL_TEMPLATE.format(method="get") post_url = self.HTTPBIN_URL_TEMPLATE.format(method="post") get_integration = apigateway.HttpIntegration(get_url) post_integration = apigateway.HttpIntegration(post_url, http_method="POST") options_integration = apigateway.HttpIntegration(get_url, http_method="OPTIONS") head_integration = apigateway.HttpIntegration(get_url, http_method="HEAD") echo.add_method("GET", get_integration) echo.add_method("OPTIONS", options_integration) echo.add_method("HEAD", head_integration) echo_post.add_method("POST", post_integration) auth.add_method("GET", get_integration, authorization_type=apigateway.AuthorizationType.IAM) apikey.add_method("GET", get_integration, api_key_required=True) # Generate all methods for /echo for method in ("put", "post", "delete", "patch"): url = self.HTTPBIN_URL_TEMPLATE.format(method=method) integration = apigateway.HttpIntegration(url, http_method=method) echo.add_method(method.upper(), integration) # Create SSM parameters for the endpoint of the API and the API key self._parameters_to_save = {"endpoint": api.url, "api_key": api_key_value} self.save_parameters_in_parameter_store(platform=Platform.ANDROID) common_stack.add_to_common_role_policies(self)
def __init__(self, scope: core.Construct, construct_id: str, apigw_role: _iam.Role, eventBus: _events.EventBus, **kwargs): super().__init__(scope, construct_id, **kwargs) integrationOptions = \ _apigw.IntegrationOptions( credentials_role=apigw_role, request_parameters={ "integration.request.header.X-Amz-Target": "'AWSEvents.PutEvents'", "integration.request.header.Content-Type": "'application/x-amz-json-1.1'", }, request_templates={ "application/json":'#set($language=$input.params(\'language\'))\n{"Entries": [{"Source": "com.amazon.alexa.$language", "Detail": ' + \ '"$util.escapeJavaScript($input.body)",' + \ ' "Resources": ["resource1", "resource2"], "DetailType": "myDetailType", "EventBusName": "' + eventBus.event_bus_name + '"}]}' }, integration_responses=[_apigw.IntegrationResponse( status_code="200", response_templates={"application/json": ""}, )] ) # Integration API Gateway with EventBridge integrationEventBridge = _apigw.Integration( type=_apigw.IntegrationType("AWS"), integration_http_method="POST", options=integrationOptions, uri= f"arn:aws:apigateway:{os.environ['CDK_DEFAULT_REGION']}:events:path//" ) myApi = _apigw.RestApi(self, construct_id) # myApi.root.add_method("POST", # integrationEventBridge, # method_responses=[ # _apigw.MethodResponse( # status_code="200" # ) # ] # ) languageResource = myApi.root.add_resource("{language}") languageResource.add_method( "POST", integrationEventBridge, method_responses=[_apigw.MethodResponse(status_code="200")], request_models={"application/json": self.getModel(myApi)}, request_validator=_apigw.RequestValidator( self, "myValidator", rest_api=myApi, validate_request_body=True))
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) api = aws_apigateway.RestApi(self, "example") create_noddy_endpoint(api.root, "GET", {"message": "hi from root!"}) apples = aws_apigateway.Resource(self, id="apples", parent=api.root, path_part="apples") create_noddy_endpoint(apples, "GET", {"message": "You have 3 apples"})
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) table = dynamo.Table( self, 'Table', table_name='subscriptions', partition_key=dynamo.Attribute(name='pk', type=dynamo.AttributeType.STRING), sort_key=dynamo.Attribute(name='sk', type=dynamo.AttributeType.STRING), time_to_live_attribute='ttl') template_name = 'EmailVerification' template = ses.CfnTemplate( self, 'Template', template={ 'htmlPart': '<div><a href="{code}">Verify Email</a></div>', 'subjectPart': 'Verify Email Address', 'templateName': template_name }) create_subscription = lambda_.Function( self, 'CreateSubscriptionFunction', function_name='create_subscription', handler='src.main.handler', code=lambda_.Code.from_asset('../functions/create_subscription'), runtime=lambda_.Runtime.PYTHON_3_7, environment={ 'TEMPLATE_NAME': template_name, 'TABLE_NAME': table.table_name }) # Update Lambda Permissions create_subscription.add_to_role_policy( iam.PolicyStatement(actions=['ses:SendEmail', 'ses:SendRawEmail'], resources=['*'])) table.grant_read_write_data(create_subscription) # API api = ag.RestApi(self, 'Api', rest_api_name='email-subscriptions') subscriptions_resource = api.root.add_resource('subscriptions') subscriptions_resource.add_method('POST', integration=ag.LambdaIntegration( handler=create_subscription, proxy=True))
def __init__(self, scope: core.Construct, id: str, func: _lambda.IFunction, **kwargs) -> None: super().__init__(scope, id, **kwargs) api = apigw.RestApi( self, "APIGateway", ) entity = api.root.add_resource("github") entity_lambda_integration = apigw.LambdaIntegration( func, proxy=True ) entity.add_method("POST", entity_lambda_integration)
def __init__(self, scope: core.App, id: str, domain: apigw.DomainName, **kwargs) -> None: super().__init__(scope, id, **kwargs) api = apigw.RestApi(self, 'api2') domain.add_base_path_mapping(api, base_path="api2") hello_handler = _lambda.Function( self, 'LambdaHandler', runtime=_lambda.Runtime.PYTHON_3_7, handler="index.handler", code=_lambda.Code.from_inline(handler_func), ) api.root.add_method("GET", apigw.LambdaIntegration(hello_handler))
def create_app(self, settings) -> aws_apigateway.RestApi: return aws_apigateway.RestApi( self, settings.AWS_API_GATEWAY_APP_NAME, # For now we do not want to keep old deployments retain_deployments=False, minimum_compression_size=10240, default_cors_preflight_options={ "allow_origins": settings.CORS_ALLOWED_ORIGINS.split(","), "allow_methods": ["GET", "POST", "OPTIONS"], }, # Because deployment is made by another stack, # we have to prevent deploying this API deploy=False, )
def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) # Lambda function hello_function = lambda_.Function( self, "hello-function", code=lambda_.Code.from_asset("src/hello/"), handler="main.handler", runtime=lambda_.Runtime.PYTHON_3_8, tracing=lambda_.Tracing.ACTIVE) logs.LogGroup( self, "hello-logs", log_group_name=f"/aws/lambda/{hello_function.function_name}", retention=logs.RetentionDays.ONE_WEEK) # API Gateway api_logs = logs.LogGroup(self, "hello-api-logs", retention=logs.RetentionDays.ONE_WEEK) api = apigw.RestApi( self, "hello-api", deploy_options=apigw.StageOptions( access_log_destination=apigw.LogGroupLogDestination(api_logs), access_log_format=apigw.AccessLogFormat. json_with_standard_fields(caller=True, http_method=True, ip=True, protocol=True, request_time=True, resource_path=True, response_length=True, status=True, user=True), throttling_burst_limit=1000, throttling_rate_limit=10, tracing_enabled=True)) hello_integration = apigw.LambdaIntegration(hello_function, proxy=True) api.root.add_method("GET", hello_integration)
def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) announcements_table = aws_dynamodb.Table( scope=self, id='announcements_table', partition_key=aws_dynamodb.Attribute( name='id', type=aws_dynamodb.AttributeType.STRING, ), ) api = aws_apigateway.RestApi( scope=self, id='announcements_rest_api_gateway', ) announcements_endpoint = api.root.add_resource('announcements') get_announcements_handler = aws_lambda_python.PythonFunction( scope=self, id='GetAnnouncementHandler', entry='lambda', index='get.py', handler='handler', runtime=aws_lambda.Runtime.PYTHON_3_8, ) create_announcement_handler = aws_lambda_python.PythonFunction( scope=self, id='CreateAnnouncementHandler', entry='lambda', index='create.py', handler='handler', runtime=aws_lambda.Runtime.PYTHON_3_6, ) announcements_table.grant_read_data(get_announcements_handler) announcements_table.grant_read_write_data(create_announcement_handler) get_announcements_handler.add_environment( 'TABLE_NAME', announcements_table.table_name) create_announcement_handler.add_environment( 'TABLE_NAME', announcements_table.table_name) get_announcements_integration = aws_apigateway.LambdaIntegration( get_announcements_handler) create_announcements_integration = aws_apigateway.LambdaIntegration( create_announcement_handler) announcements_endpoint.add_method('GET', get_announcements_integration) announcements_endpoint.add_method('POST', create_announcements_integration)
def __init__(self, scope: core.Construct, id: str): super().__init__(scope, id) bucket = s3.Bucket(self, "ResumeStore") handler = lambda_.Function(self, "ResumeHandler", runtime=lambda_.Runtime.NODEJS_10_X, code=lambda_.Code.asset("resources"), handler="resume.main", environment=dict(BUCKET=bucket.bucket_name)) bucket.grant_read_write(handler) api = apigateway.RestApi( self, "resume-api", rest_api_name="Resume Service", description="This service serves Resume Module.") get_widgets_integration = apigateway.LambdaIntegration( handler, request_templates={"application/json": '{ "statusCode": "200" }'}) api.root.add_method("GET", get_widgets_integration) # GET / print(id) widget = api.root.add_resource("{id}") # resumeData = api.root.add_resource('data') # resumeData.add_method('POST') # resumeData.add_method('GET') # Add new widget to bucket with: POST /{id} post_widget_integration = apigateway.LambdaIntegration(handler) # Get a specific widget from bucket with: GET /{id} get_widget_integration = apigateway.LambdaIntegration(handler) # Remove a specific widget from the bucket with: DELETE /{id} delete_widget_integration = apigateway.LambdaIntegration(handler) widget.add_method("POST", post_widget_integration) # POST /{id} widget.add_method("GET", get_widget_integration) # GET /{id} widget.add_method("DELETE", delete_widget_integration)
def __init__(self, scope: core.Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) # Ensure the Cognito ARN is set cognito_arn = os.environ.get('COGNITO_ARN') if cognito_arn is None: raise ValueError( 'An environment variable for COGNITO_ARN is required') # Deploy Lambda my_lambda = _lambda.Function( self, 'HelloHandler', runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hello.handler', ) # create the API gateway api = apigw.RestApi( self, 'HelloHandler2', rest_api_name="LCAOA_Demo", description="Demo of lambda, cognito, Azure AD and OpenId auth" ) # configure the Authorizer auth = apigw.CfnAuthorizer( scope=self, id='cognito_authorizer', rest_api_id=api.rest_api_id, name='MyAuth', type='COGNITO_USER_POOLS', identity_source='method.request.header.Authorization', provider_arns=[ cognito_arn ] ) resource = api.root.add_resource("endpoint") lambda_integration = apigw.LambdaIntegration( my_lambda, proxy=True) method = resource.add_method("GET", lambda_integration) method_resource = method.node.find_child('Resource') method_resource.add_property_override( 'AuthorizationType', 'COGNITO_USER_POOLS') method_resource.add_property_override( 'AuthorizerId', {"Ref": auth.logical_id})