Merge pull request pulumi#732 from pulumi/zephyrz73/serverless-raw-co…

…nversion

1. Change the netcore version to 3.1
2. Converted the project aws-ts-serverless-raw into aws-py-serverless-raw

aws-py-serverless-raw/.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+venv/

aws-py-serverless-raw/Pulumi.yaml

@@ -0,0 +1,9 @@
+name: serverless-raw
+runtime: python
+description: Basic example of a serverless AWS application
+template:
+  config:
+    aws:region:
+      description: The AWS region to deploy into
+      default: us-east-2
+

aws-py-serverless-raw/README.md

@@ -0,0 +1,84 @@
+[![Deploy](https://get.pulumi.com/new/button.svg)](https://app.pulumi.com/new)
+
+# Serverless C# App
+
+This example deploys a complete serverless C# application using raw `aws.apigateway.RestApi`, `aws.lambda_.Function` and
+`aws.dynamodb.Table` resources from `pulumi_aws`.  Although this doesn't feature any of the higher-level abstractions
+from the `pulumi_cloud` package, it demonstrates that you can program the raw resources directly available in AWS
+to accomplish all of the same things this higher-level package offers.
+
+The deployed Lambda function is a simple C# application, highlighting the ability to manage existing application code
+in a Pulumi application, even if your Pulumi code is written in a different language like JavaScript or Python.
+
+The Lambda function is a C# application using .NET Core 3.1 (a similar approach works for any other language supported by
+AWS Lambda).
+
+## Deploying and running the Pulumi App
+1. Install dependencies. In this example we will install them in a virtual environment named `venv`.
+    ```bash
+    $ python3 -m venv venv
+    $ source venv/bin/activate
+    $ pip install -r requirements.txt
+    ```
+
+1.  Create a new stack:
+
+    ```bash
+    $ pulumi stack init dev
+    ```
+
+1.  Build the C# application.
+
+    ```bash
+    dotnet publish app
+    ```
+
+1.  Set the AWS region:
+
+    ```bash
+    $ pulumi config set aws:region us-east-2
+    ```
+
+1.  Optionally, set AWS Lambda provisioned concurrency:
+
+    ```bash
+    $ pulumi config set provisionedConcurrency 1
+    ```
+
+1.  Run `pulumi up` to preview and deploy changes:
+
+    ```
+    $ pulumi up
+    Previewing update (dev):
+    ...
+
+    Updating (dev):
+    ...
+    Resources:
+        + 10 created
+    Duration: 1m 20s
+    ```
+
+1.  Check the deployed GraphQL endpoint:
+
+    ```
+    $ curl $(pulumi stack output endpoint)/hello
+    {"Path":"/hello","Count":0}
+    ```
+
+1.  See the logs
+
+    ```
+    $ pulumi logs -f
+    2018-03-21T18:24:52.670-07:00[    mylambda-d719650] START RequestId: d1e95652-2d6f-11e8-93f6-2921c8ae65e7 Version: $LATEST
+    2018-03-21T18:24:56.171-07:00[    mylambda-d719650] Getting count for '/hello'
+    2018-03-21T18:25:01.327-07:00[    mylambda-d719650] Got count 0 for '/hello'
+    2018-03-21T18:25:02.267-07:00[    mylambda-d719650] END RequestId: d1e95652-2d6f-11e8-93f6-2921c8ae65e7
+    2018-03-21T18:25:02.267-07:00[    mylambda-d719650] REPORT RequestId: d1e95652-2d6f-11e8-93f6-2921c8ae65e7   Duration: 9540.93 ms    Billed Duration: 9600 ms        Memory Size: 128 MB     Max Memory Used: 37 MB
+    ```
+
+## Clean up
+
+1.  Run `pulumi destroy` to tear down all resources.
+
+1.  To delete the stack itself, run `pulumi stack rm`. Note that this command deletes all deployment history from the Pulumi Console.

aws-py-serverless-raw/__main__.py

@@ -0,0 +1,160 @@
+"""Copyright 2016-2019, Pulumi Corporation.  All rights reserved."""
+import pulumi
+import pulumi_aws as aws
+import pulumi_aws.config
+from pulumi import Output
+import json
+
+# The location of the built dotnet3.1 application to deploy
+dotnet_application_publish_folder = "./app/bin/Debug/netcoreapp3.1/publish"
+dotnet_application_entry_point = "app::app.Functions::GetAsync"
+# The stage name to use for the API Gateway URL
+custom_stage_name = "api"
+
+#################
+## DynamoDB Table
+#################
+
+# A DynamoDB table with a single primary key
+counter_table = aws.dynamodb.Table("counterTable",
+    attributes=[
+        {
+            "name": "Id",
+            "type": "S",
+        },
+    ],
+    hash_key="Id",
+    read_capacity=1,
+    write_capacity=1,
+    )
+
+##################
+## Lambda Function
+##################
+
+# Give our Lambda access to the Dynamo DB table, CloudWatch Logs and Metrics
+# Python package does not have assumeRolePolicyForPrinciple
+instance_assume_role_policy = aws.iam.get_policy_document(statements=[{
+    "actions": ["sts:AssumeRole"],
+    "principals": [{
+        "identifiers": ["lambda.amazonaws.com"],
+        "type": "Service",
+    }],
+}])
+
+role = aws.iam.Role("mylambda-role",
+    assume_role_policy=instance_assume_role_policy.json,
+    )
+
+policy = aws.iam.RolePolicy("mylambda-policy",
+    role=role,
+    policy=Output.from_input({
+        "Version": "2012-10-17",
+        "Statement": [{
+            "Action": ["dynamodb:UpdateItem", "dynamodb:PutItem", "dynamodb:GetItem",
+                        "dynamodb:DescribeTable"],
+            "Resource": counter_table.arn,
+            "Effect": "Allow",
+        }, {
+            "Action": ["logs:*", "cloudwatch:*"],
+            "Resource": "*",
+            "Effect": "Allow",
+        }],
+    }),
+    )
+
+# Read the config of whether to provision fixed concurrency for Lambda
+config = pulumi.Config()
+provisioned_concurrent_executions = config.get_float('provisionedConcurrency')
+
+# Create a Lambda function, using code from the `./app` folder.
+
+lambda_func = aws.lambda_.Function("mylambda",
+    opts=pulumi.ResourceOptions(depends_on=[policy]),
+    runtime="dotnetcore3.1",
+    code=pulumi.AssetArchive({
+        ".": pulumi.FileArchive(dotnet_application_publish_folder),
+    }),
+    timeout=300,
+    handler=dotnet_application_entry_point,
+    role=role.arn,
+    publish=bool(provisioned_concurrent_executions),
+    # Versioning required for provisioned concurrency
+    environment={
+        "variables": {
+            "COUNTER_TABLE": counter_table.name,
+        },
+    },
+    )
+
+if provisioned_concurrent_executions:
+    concurrency = aws.lambda_.ProvisionedConcurrencyConfig("concurrency",
+    function_name=lambda_func.name,
+    qualifier=lambda_func.version,
+    provisioned_concurrent_executions=provisioned_concurrent_executions,
+    )
+
+
+#####################
+## APIGateway RestAPI
+######################
+
+# Create the Swagger spec for a proxy which forwards all HTTP requests through to the Lambda function.
+def swagger_spec(lambda_arn):
+    swagger_spec_returns = {
+        "swagger": "2.0",
+        "info": {"title": "api", "version": "1.0"},
+        "paths": {
+            "/{proxy+}": swagger_route_handler(lambda_arn),
+        },
+    }
+    return json.dumps(swagger_spec_returns)
+
+
+# Create a single Swagger spec route handler for a Lambda function.
+def swagger_route_handler(lambda_arn):
+    region = pulumi_aws.config.region
+    uri_string = 'arn:aws:apigateway:{region}:lambda:path/2015-03-31/functions/{lambdaArn}/invocations'.format(
+        region=region, lambdaArn=lambda_arn)
+    return ({
+        "x-amazon-apigateway-any-method": {
+            "x-amazon-apigateway-integration": {
+                "uri": uri_string,
+                "passthroughBehavior": "when_no_match",
+                "httpMethod": "POST",
+                "type": "aws_proxy",
+            },
+        },
+    })
+
+
+# Create the API Gateway Rest API, using a swagger spec.
+rest_api = aws.apigateway.RestApi("api",
+    body=lambda_func.arn.apply(lambda lambda_arn: swagger_spec(lambda_arn)),
+    )
+
+# Create a deployment of the Rest API.
+deployment = aws.apigateway.Deployment("api-deployment",
+    rest_api=rest_api,
+    # Note: Set to empty to avoid creating an implicit stage, we'll create it
+    # explicitly below instead.
+    stage_name="")
+
+# Create a stage, which is an addressable instance of the Rest API. Set it to point at the latest deployment.
+stage = aws.apigateway.Stage("api-stage",
+    rest_api=rest_api,
+    deployment=deployment,
+    stage_name=custom_stage_name,
+    )
+
+# Give permissions from API Gateway to invoke the Lambda
+invoke_permission = aws.lambda_.Permission("api-lambda-permission",
+    action="lambda:invokeFunction",
+    function=lambda_func,
+    principal="apigateway.amazonaws.com",
+    source_arn=deployment.execution_arn.apply(
+        lambda execution_arn: execution_arn + "*/*"),
+    )
+
+# Export the https endpoint of the running Rest API
+pulumi.export("endpoint", deployment.invoke_url.apply(lambda url: url + custom_stage_name))

aws-py-serverless-raw/app/Functions.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+
+using Amazon.Lambda.Core;
+using Amazon.Lambda.APIGatewayEvents;
+
+using Amazon;
+using Amazon.DynamoDBv2;
+using Amazon.DynamoDBv2.DataModel;
+
+using Newtonsoft.Json;
+
+// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
+[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
+
+namespace app
+{
+    public class Counter
+    {
+        public string Id { get; set; }
+        public Int32 Count { get; set; }
+    }
+
+    public class Functions
+    {
+        // This const is the name of the environment variable that the serverless.template will use to set
+        // the name of the DynamoDB table used to store blog posts.
+        const string TABLENAME_ENVIRONMENT_VARIABLE_LOOKUP = "COUNTER_TABLE";
+
+        IDynamoDBContext DDBContext { get; set; }
+
+        /// <summary>
+        /// Default constructor that Lambda will invoke.
+        /// </summary>
+        public Functions()
+        {
+            // Check to see if a table name was passed in through environment variables and if so 
+            // add the table mapping.
+            var tableName = System.Environment.GetEnvironmentVariable(TABLENAME_ENVIRONMENT_VARIABLE_LOOKUP);
+            if(!string.IsNullOrEmpty(tableName))
+            {
+                AWSConfigsDynamoDB.Context.TypeMappings[typeof(Counter)] = new Amazon.Util.TypeMapping(typeof(Counter), tableName);
+            }
+
+            var config = new DynamoDBContextConfig { Conversion = DynamoDBEntryConversion.V2 };
+            this.DDBContext = new DynamoDBContext(new AmazonDynamoDBClient(), config);
+        }
+
+        /// <summary>
+        /// A Lambda function that returns a simple JSON object.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public async Task<APIGatewayProxyResponse> GetAsync(APIGatewayProxyRequest request, ILambdaContext context)
+        {
+            context.Logger.LogLine($"Getting count for '{request.Path}'");
+
+            var counter = await DDBContext.LoadAsync<Counter>(request.Path);
+            if (counter == null) {
+                counter = new Counter { Id = request.Path, Count = 1 };
+            }
+            var count = counter.Count++;
+            await DDBContext.SaveAsync<Counter>(counter);
+
+            context.Logger.LogLine($"Got count {count} for '{request.Path}'");
+
+            var response = new APIGatewayProxyResponse
+            {
+                StatusCode = (int)HttpStatusCode.OK,
+                Body = JsonConvert.SerializeObject(new { Path = request.Path, Count = count }),
+                Headers = new Dictionary<string, string> { { "Content-Type", "application/json" } }
+            };
+
+            return response;
+        }
+
+    }
+}

aws-py-serverless-raw/app/app.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AWSSDK.DynamoDBv2" Version="3.3.5" />
+
+    <PackageReference Include="Amazon.Lambda.Core" Version="1.0.0" />
+    <PackageReference Include="Amazon.Lambda.Serialization.Json" Version="1.1.0" />
+    <PackageReference Include="Amazon.Lambda.APIGatewayEvents" Version="1.1.2" />
+
+    <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <DotNetCliToolReference Include="Amazon.Lambda.Tools" Version="2.1.1" />
+  </ItemGroup>
+
+</Project>

aws-py-serverless-raw/requirements.txt

@@ -0,0 +1,3 @@
+grpcio>=1.9.1,!=1.30.0
+pulumi>=2.0.0,<3.0.0
+pulumi-aws>=2.0.0,<3.0.0

aws-ts-serverless-raw/app/.gitignore → aws-ts-serverless-raw/.gitignore

@@ -1,2 +1,3 @@
 /**/obj
 /**/bin
+/**/node_modules

aws-ts-serverless-raw/README.md

@@ -10,7 +10,7 @@ to accomplish all of the same things this higher-level package offers.
 The deployed Lambda function is a simple C# application, highlighting the ability to manage existing application code
 in a Pulumi application, even if your Pulumi code is written in a different language like JavaScript or Python.
 
-The Lambda function is a C# application using .NET Core 2.1 (a similar approach works for any other language supported by
+The Lambda function is a C# application using .NET Core 3.1 (a similar approach works for any other language supported by
 AWS Lambda).
 
 ## Deploying and running the Pulumi App

aws-ts-serverless-raw/app/app.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
   </PropertyGroup>