8 |
9 | ## Initial environment setup
10 |
11 | ### Prerequisites
12 |
13 | #### Laptop Machine
14 |
15 | A laptop with Wi-Fi running Microsoft Windows or Mac OS X with the following software installed:
16 |
17 | - Visual Studio Code (its installation is covered during Lab 0)
18 | - An Internet browser such as Chrome, Firefox, Safari, or Edge.
19 | - Ability to SSH with port forwarding (ssh or Putty)
20 |
21 | #### AWS Account
22 |
23 | - Ability to create AWS resources including EC2, Amazon Cognito, AWS Lambda, Amazon Api Gateway, Amazon S3 and IAM Roles.
24 | - Amazon EC2 key pair created in the AWS region you are working on. Learn how to [create a key pair](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
25 |
26 | :warning: **Important Note: This guide creates chargeable AWS resources.** You may wish to remove these resources upon completion of the guide to avoid incurring future charges to your account. To do this, be sure to follow the instructions in *Clean up* module.
27 |
28 | ## Labs
29 |
30 | Follow the modules to configure and deploy the AspNetCore application to AWS successfully.
31 |
32 | | Labs |
33 | | ------------- |
34 | | [0 - Setting up AWS Tools and credentials](lab-0-tools-and-cred/) |
35 | | [1 - Creating the AspNetCore](lab-1-aspnetcore/) |
36 | | [2 - Adding OpenId to AspNetCore WebApp](lab-2-openid/) |
37 | | [3 - Creating the backend serverless dotnet app](lab-3-backend/) |
38 | | [4 - Putting it all together](lab-4-alltogether/) |
39 | | [5 - (Optional) Improving monitoring with AWS X-Ray](lab-5-xray/) |
40 | | [99- Clean up](lab-99-clean-up/) |
--------------------------------------------------------------------------------
/SupportCommands.md:
--------------------------------------------------------------------------------
1 | # Supporting commands
2 | This section provides a list of useful commands that help you identify the names of the resources created in the labs. Most of the commands executed in the labs require you to know the resources, like S3 bucket and Api Gateway Id.
3 |
4 | ## Amazon S3 bucket name
5 | To obtain the Amazon S3 bucket name required for deploying the packages, query the resources created for the *first initial* + *last initial* + *-dotnetcore-devbox*, by executing ```aws cloudformation describe-stack-resources --stack-name 
33 |
34 | 3. In the Search Extensions field type the packages names below and Click on *install*. For more information about how to manage Visual Studio Code Extensions, click [here](https://code.visualstudio.com/docs/editor/extension-gallery)
35 | ```
36 | ms-vscode-remote.remote-ssh
37 | ms-vscode.csharp
38 | ```
39 |
40 | 4. Click on the *Manage* icon again, and check for Updates or install a pending Update. Restart VSCode if needed.
41 |
42 | ### Setting the Remove Developer Extension
43 |
44 | 1. Log into the [CloudFormation Management Console](https://console.aws.amazon.com/cloudformation/home).
45 | 2. Check the status of the CloudFormation stack you have created at step1. Wait until the Status is complete.
46 | 3. Go to the Outputs tab, and make a note of the **S3BucketName** and **PublicIP**, as you will need this information for the next steps.
47 |
48 | 
49 |
50 | 4. Login to the development box. Specify the appropriate private key and ``PublicIP`` from the EC2 instance. See below ways to connect.
51 |
52 | #### Visual Studio Code (Mac or Windows) - The recommended way for this workshop
53 |
54 | 1. Open Visual Studio Code. If the **Remote Developer Extension** is not installed, go back to **Step 1** to perform its installation.
55 |
56 | 2. Navigate to the Remote Explorer extension.
57 |
58 | 
59 |
60 | 3. Click on the **gear icon** next to the SSH Targets to create a configuration file. It will generate a new file with default values.
61 |
62 | 
63 |
64 | 4. Provide the host entry with values from the template below. Replace the **Host**, **HostName**, and **IdentityFile** as shown below. After saving the config, an SSH Target will appear. If not, close and reopen Visual Studio Code.
65 |
66 | #### Mac
67 | ```
68 | Host devbox-dotnet
69 | HostName 
84 |
85 | 1. Click the **Connect to Host in New Window** icon next to the listed SSH Target. After connecting, select **New Terminal** from the **Terminal** menu in the Visual Studio Code. This action will open a terminal session with the devbox EC2 Linux instance created by the cloudFormation script.
86 |
87 |
90 |
91 | #### Other options to connect to the dotnetcore-devbox
92 | These options are available for you to connect directly to the Amazon EC2 instance to execute the commands required from this workshop. Hence, the files need to be directly edited on the Amazon EC2 Linux instance using a text editor like **vi**, **vim** or **nano**, which is not in the scope of this workshop.
93 |
94 |
95 |
101 |
102 | Mac (SSH)(expand for details)
96 | ``` 97 | ssh -i path/to/EC2PrivateKey ec2-user@PublicIp -L localhost:3000:localhost:3000 98 | ``` 99 | 100 |
103 |
120 |
121 | ***You have now completed this lab and can move onto [Lab 1](../lab-1-aspnetcore/).***
122 |
--------------------------------------------------------------------------------
/lab-1-aspnetcore/README.md:
--------------------------------------------------------------------------------
1 | # Lab 1: Creating the AspNetCore application
2 |
3 | The steps in this Lab will create a new AWS lambda AspNetCore to act as your main website. We will also install all the required nuget packages and add/change the code for the workshop.
4 |
5 | ## Step 1: using dotnet cli to create a new project
6 |
7 | 1. Go to **Terminal** menu and select **New Terminal**
8 |
9 | Windows (Putty)(expand for details)
104 |
105 | 1. Convert your EC2 Private Key. Follow the steps [here](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) if necessary.
106 |
107 | 2. Specify the ``ec2-user@PublicIP`` in the Host Name field.
108 |
109 | 
110 |
111 | 3. Specify the converted .ppk file in the SSH/Auth ``Private key file for authentication`` field.
112 |
113 | 
114 |
115 | 4. Configure tunneling for localhost:3000 in the SSH/Tunnels. Specify the ``Source port`` and ``Destination`` and click **Add**.
116 |
117 | 
118 |
119 |
10 |
11 | 1. Configure the AWS region in your terminal by executing ```aws configure```. Provide information solely to the **Default region name**. In the example below, the *Default region name* was set to Oregon (us-west-2).
12 | ```
13 | [ec2-user@ip-172-17-2-121 WebApp]$ aws configure
14 | AWS Access Key ID [None]:
15 | AWS Secret Access Key [None]:
16 | Default region name [None]: us-west-2
17 | Default output format [None]:
18 | ```
19 | 2. Install the AWS extensions for the dotnet CLI.
20 | ```bash
21 | dotnet tool install -g Amazon.Lambda.Tools
22 | ```
23 | 3. Install the Amazon.Lambda.Templates blueprints by executing the following command :
24 | ```bash
25 | dotnet new -i "Amazon.Lambda.Templates::*"
26 | ```
27 | 4. To see a list of the Lambda templates execute ```dotnet new lambda --list```
28 | 5. Create the *WebApp* project running the following command.
29 |
30 | :warning: **The project name has to be named WebApp (capital W and capital A) as all the workshop modules are based on this name**.
31 |
32 | ```bash
33 | dotnet new serverless.AspNetCoreWebApp --name WebApp
34 | ```
35 |
36 | 6. You now have a directory called WebApp with a C# project template for AspNetCore application.
37 |
38 | 7. Go to File -> *Open* and select **/home/ec2-user/WebApp/src/WebApp/**. It will load all the sub-directories and files for you.
39 |
40 | 
41 |
42 | ### Step 2: Publishing the serverless.AspNetCoreWebApp to AWS
43 | Using the dotnet cli we will deploy our AspNet Core WebApp to AWS.
44 |
45 | 1. Edit the **serverless.template** file. We are going to add Add the lines ```"Tracing": "Active"``` and the Policies: ```"Policies": [ "AWSLambdaFullAccess", "AmazonSSMFullAccess" ],```. Replace the **serverless.template** content with the content below. Don't forget to save the file before moving to the next step.
46 |
47 | ```json
48 | {
49 | "AWSTemplateFormatVersion": "2010-09-09",
50 | "Transform": "AWS::Serverless-2016-10-31",
51 | "Description": "An AWS Serverless Application that uses the ASP.NET Core framework running in Amazon Lambda.",
52 | "Parameters": {},
53 | "Conditions": {},
54 | "Resources": {
55 | "AspNetCoreFunction": {
56 | "Type": "AWS::Serverless::Function",
57 | "Properties": {
58 | "Handler": "WebApp::WebApp.LambdaEntryPoint::FunctionHandlerAsync",
59 | "Runtime": "dotnetcore3.1",
60 | "CodeUri": "",
61 | "MemorySize": 512,
62 | "Timeout": 30,
63 | "Role": null,
64 | "Policies": [ "AWSLambdaFullAccess", "AmazonSSMFullAccess" ],
65 | "Tracing": "Active",
66 | "Environment": {
67 | "Variables": {}
68 | },
69 | "Events": {
70 | "ProxyResource": {
71 | "Type": "Api",
72 | "Properties": {
73 | "Path": "/{proxy+}",
74 | "Method": "ANY"
75 | }
76 | },
77 | "RootResource": {
78 | "Type": "Api",
79 | "Properties": {
80 | "Path": "/",
81 | "Method": "ANY"
82 | }
83 | }
84 | }
85 | }
86 | }
87 | },
88 | "Outputs": {
89 | "ApiURL": {
90 | "Description": "API endpoint URL for Prod environment",
91 | "Value": {
92 | "Fn::Sub": "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
93 | }
94 | }
95 | }
96 | }
97 | ```
98 |
99 | 2. Execute the following command:
100 |
101 | :notebook: **Reminder**: To see all the resources created : ```aws cloudformation describe-stack-resources --stack-name DotNetLab --query 'StackResources[*].{Type:ResourceType,Id:PhysicalResourceId}' --output text``` to see all the resources created. The [Support Commands Page](/SupportCommands.md) provides a list of useful commands that help you identify the names of the resources created in the labs.
102 |
103 | ```bash
104 | dotnet lambda deploy-serverless --template serverless.template --s3-bucket 
118 |
119 | 5. Let's check the cloudformation stack resources that were created for the AspNetCoreWebApp. The dotnet lambda blueprint took care of creating an Amazon API Gateway, IAM Roles and its policies and the Lambda itself. The following command shows the resource types and their Ids.
120 |
121 | ```bash
122 | aws cloudformation describe-stack-resources --stack-name AspNetCoreWebApp --query 'StackResources[*].{Type:ResourceType,Id:PhysicalResourceId}' --output text
123 | ```
124 |
125 | ### Step 3: Installing the Nuget packages
126 | Now it is time to prepare our application to integrate with the AWS resources we want by adding the AWS libraries to our project.
127 |
128 | 1. From the Visual Code terminal you will install the nuget packages, like at the screenshot below:
129 |
130 | 
131 |
132 | :notebook: **Note:** *You can copy and paste all the lines below into the terminal prompt. The last line pasted still need to you press ENTER to install it*.
133 |
134 | ```bash
135 | dotnet add package Newtonsoft.Json --version 12.0.3
136 | dotnet add package AWSSDK.Core --version 3.3.107.9
137 | dotnet add package AWSSDK.Lambda --version 3.3.109.39
138 | dotnet add package Amazon.Lambda.Core --version 1.1.0
139 | dotnet add package AWSSDK.Extensions.NETCore.Setup --version 3.3.101
140 | dotnet add package AWS.Logger.Core --version 1.6.0
141 | dotnet add package AWSSDK.S3 --version 3.3.111.10
142 | dotnet add package AWSSDK.SimpleSystemsManagement --version 3.3.125.2
143 | dotnet add package Amazon.Lambda.APIGatewayEvents --version 2.1.0
144 | dotnet add package AWSSDK.CognitoIdentityProvider --version 3.3.109.49
145 | dotnet add package Amazon.AspNetCore.DataProtection.SSM --version 1.1.0
146 | dotnet add package Microsoft.AspNetCore.Authentication.OpenIdConnect --version 3.1.5
147 | dotnet add package Microsoft.AspNetCore.Authentication.Cookies --version 2.2.0
148 | ```
149 |
150 | :warning: if you copy and past the code above into the terminal you may have to hit **ENTER** one more time to install the last line.
151 |
152 |
153 | 1. You can verify if all the packages were installed by looking at the WebApp.csproj
154 | ```bash
155 | cat WebApp.csproj
156 | ```
157 | 3. At the terminal windows, let's confirm that our code compiles with no errors
158 | ```bash
159 | dotnet publish -c Release
160 | ```
161 |
162 | ***You have now completed this lab and can move onto [Lab 2](../lab-2-openid/).***
163 |
--------------------------------------------------------------------------------
/lab-2-openid/README.md:
--------------------------------------------------------------------------------
1 | # Lab 2: Adding OpenId to AspNetCore
2 | In this Lab, the AWS Lambda AspNetCoreWebApp is going to be integrated with Amazon Cognito by using OpenID.
3 |
4 | ### Step 1: Creating a User Pool
5 | This step will create an Amazon Cognito user pool. A user pool is a user directory in Amazon Cognito. With a user pool, your users can sign in to your web or mobile app through Amazon Cognito.
6 |
7 | 1. Using the Visual Code terminal, executing the following cli command to create an Amazon Cognito user pool.
8 | ```bash
9 | aws cognito-idp create-user-pool --pool-name DotNetCognitoUserPool --auto-verified-attributes email --username-attributes email --mfa-configuration OFF --schema '[{"Name":"given_name","Required":true},{"Name":"family_name","Required":true},{"Name":"email","Required":true}]'
10 | ```
11 | :exclamation: Don't forget to take a note of the **PoolId** and **Pool ARN**. You will need these information to set up the OpenId library. The PoolID and Pool Arn can be copied from the command output. They appear at the **Id** and **Arn** fields, as the example below:
12 |
13 | ```json
14 | "CreationDate": 1583628374.102,
15 | "EstimatedNumberOfUsers": 0,
16 | "Id": "us-west-2_abcdef123",
17 | "Arn": "arn:aws:cognito-idp:us-west-2:000000000000:userpool/us-west-2_abcdef123",
18 | "LambdaConfig": {}
19 | ```
20 |
21 | :notebook: **Note** In this workshop, we won't create an Identity Pool. With an identity pool, your users from the user pool can obtain temporary AWS credentials to access AWS services, such as Amazon S3 and DynamoDB.
22 |
23 | 2. An app is an entity within a user pool that has permission to call unauthenticated APIs (APIs that do not have an authenticated user), such as APIs to register, sign in, and handle forgotten passwords. To call these APIs, you need an app client ID and an optional client secret. The aws cli command below creates an user pool client. Make sure to replace the **PoolId**, the URL prefix created for your AspNetWebApp lambda on the previous lab, and the **AWS Region** in the command.
24 |
25 | :notebook: **Note** You can find **restApiId** by running ```aws apigateway get-rest-apis --query 'items[*].{name:name,restApiId:id}'```. The output will shows all the restApiId. Copy the one that contains **AspNetCoreWebApp**
26 |
27 | ```json
28 | [
29 | {
30 | "restApiId": "aws43ro5672",
31 | "name": "ApiTest"
32 | },
33 | {
34 | "restApiId": "aws57ro2934",
35 | "name": "AspNetCoreWebApp"
36 | }
37 | ]
38 | ```
39 |
40 | :warning: **Attention** The command below requires you to replace **poolId**, **awsRegion** and **restApiId**
41 |
42 | ```bash
43 | aws cognito-idp create-user-pool-client --user-pool-id 
142 |
143 | 7. Click on **Sign up** at the login prompt.
144 | 8. Fill up the **Sign up with a new account** fields accordingly (using a valid email address) and create the user by clicking on **Sign up** button.
145 | 9. Check your email inbox for a message from *no-reply@verificationemail.com*, which contains your verification code. Type it in the verification code prompt and **Confirm Account**.
146 | 10. You should now be able to access the AspNetCore WebApp.
147 |
148 | :notebook: **Note:** for more information about ASP.NET Core web applications using ASP.NET Core Identity with Amazon Cognito access [here](https://github.com/aws/aws-aspnet-cognito-identity-provider).
149 |
150 | ***You have now completed this lab and can move onto [Lab 3](../lab-3-backend/).***
151 |
--------------------------------------------------------------------------------
/lab-2-openid/Startup.cs:
--------------------------------------------------------------------------------
1 | // Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | // SPDX-License-Identifier: MIT-0
3 |
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Linq;
7 | using System.Threading.Tasks;
8 | using Microsoft.AspNetCore.Authentication.Cookies;
9 | using Microsoft.AspNetCore.Authentication.OpenIdConnect;
10 | using Microsoft.AspNetCore.Builder;
11 | using Microsoft.AspNetCore.Hosting;
12 | using Microsoft.AspNetCore.Http;
13 | using Microsoft.AspNetCore.Mvc;
14 | using Microsoft.Extensions.Configuration;
15 | using Microsoft.Extensions.DependencyInjection;
16 | using Microsoft.Extensions.Options;
17 | using Microsoft.IdentityModel.Tokens;
18 | using Amazon.CognitoIdentityProvider;
19 | using Amazon.Lambda.Core;
20 | using Microsoft.Extensions.Logging;
21 | using Amazon.S3;
22 | using Amazon.Lambda;
23 | using System.IO;
24 |
25 | namespace WebApp
26 | {
27 | public class Startup
28 | {
29 | public Startup(IConfiguration configuration)
30 | {
31 | Configuration = configuration;
32 | }
33 |
34 | public IConfiguration Configuration { get; }
35 |
36 | public void ConfigureServices(IServiceCollection services)
37 | {
38 |
39 | services.Configure
10 |
11 | 2. Go to **Terminal** menu and select **New Terminal**. In the terminal, execute the command below:
12 |
13 | :warning: **The project name has to be named CustomerList (capital C and capital L) as all the workshop modules are based on this name**.
14 |
15 | ```
16 | dotnet new lambda.EmptyFunction --name CustomerList
17 | ```
18 |
19 | 3. You now have a directory called **CustomerList** with a C# project template for a NetCore application.
20 |
21 | 4. Go to File -> *Open* and select the **/home/ec2-user/CustomerList/src/CustomerList** folder. It will load all the sub-directories and files for you.
22 |
23 | 
24 |
25 | :exclamation: We will run all the commands using this terminal window. Keep it opened.
26 |
27 | ### Step 2: Publishing the serverless.AspNetCoreWebApp to AWS
28 | We will create an AWS Serverless Application Model [SAM](https://github.com/awslabs/serverless-application-model) template to instruct the dotnet cli to provision our microservices.
29 |
30 | 1. From the Visual Code terminal windows execute the following commands:
31 |
32 | :notebook: **Note:** *You can copy and paste all the lines below into the terminal prompt. The last line pasted still need a ENTER to be installed*.
33 |
34 | ```bash
35 | dotnet add package Newtonsoft.Json --version 12.0.3
36 | dotnet add package AWSSDK.Core --version 3.3.107.9
37 | dotnet add package AWSSDK.Lambda --version 3.3.109.39
38 | dotnet add package Amazon.Lambda.Core --version 1.1.0
39 | dotnet add package AWSSDK.Extensions.NETCore.Setup --version 3.3.101
40 | dotnet add package AWS.Logger.Core --version 1.6.0
41 | dotnet add package AWSSDK.S3 --version 3.3.111.10
42 | dotnet add package Amazon.Lambda.APIGatewayEvents --version 2.1.0
43 | dotnet add package AWSSDK.CognitoIdentityProvider --version 3.3.109.49
44 | ```
45 |
46 | 1. Replace the entire **Function.cs** code with the following [Function.cs](Function.cs). This file is available in this repo at the lab-3-backend.
47 |
48 | :notebook: **Note:** This is a simple code that only makes a RestApi call to a [on-line tool](https://uinames.com/) to generate fake names. It defines the POCO classes to map API call results. The lambda function replies back to Amazon ApiGateway using a json structure based on the [APIGatewayProxyResponse](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.APIGatewayEvents/APIGatewayProxyResponse.cs), which is the required format for Lambda Proxy Integration. More information at [Set up Lambda Proxy Integration in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html)
49 |
50 | 2. At the left panel of the **Visual Studio Code** right-click on the **CustomerList** directory and select New File, name it [cfn-sam-deployment.yaml](cfn-sam-deployment.yaml). Its content can be downloaded by clicking on cfn-sam-deployment.yaml. The file is available in this repo at the lab-3-backend.
51 |
52 | :notebook: **Note:** the cfn-sam-deployment.yaml is a [SAM](https://github.com/awslabs/serverless-application-model) cloudformation file, that creates the Amazon API Gateway and its integration with an existent Amazon Cognito. It also creates and deploys the lambda function with all permissions and integrations required for the function to work.
53 |
54 | 3. Compile the new code to create the binaries that will be deployed.
55 | ```bash
56 | dotnet publish -c Release
57 | ```
58 |
59 | 4. Execute the following command to deploy the new function to AWS. **Use the same backet bucket from lab1**. Don't forget to replace the **Amazon Cognito User Pool Id** on the command:
60 |
61 | :notebook: **Note**: The [Support Commands Page](/SupportCommands.md) provides a list of useful commands that helps you identify the resources' names created during the labs executions; like the Amazon S3 bucked required for deployment and the Amazon Cognito User Pool Id.
62 | ```bash
63 | dotnet lambda deploy-serverless --template cfn-sam-deployment.yaml --s3-bucket 
101 |
102 | 6. Deploy a new version of Amazon API Gateway by going to **Actions** at the top left -> **Deploy API**.
103 |
104 | 7. Select **v1** for the **Deployment stage** and click on Deploy.
105 |
106 | 
107 |
108 | 8. After successfully deploying the API, select **Authorizers**. You will notice that Amazon API Gateway is integrated with Amazon Cognito for authentication. When calling a REST API that requires authentication, you must use the **Authorization** key in the header of the call, with the JWT token provided by Amazon Cognito.
109 |
110 | 
111 |
112 | ***You have now completed this Lab and can move onto [Lab 4](../lab-4-alltogether/).***
113 |
--------------------------------------------------------------------------------
/lab-3-backend/cfn-sam-deployment.yaml:
--------------------------------------------------------------------------------
1 | AWSTemplateFormatVersion: '2010-09-09'
2 | Transform: AWS::Serverless-2016-10-31
3 | Description: Sample SAM Template for DotNet Lambda Functions
4 | Parameters:
5 | ASPNETCOREENVIRONMENT:
6 | Type: String
7 | Default: Development
8 | UserPoolId:
9 | Type: String
10 |
11 | Resources:
12 |
13 | ServiceApi:
14 | Type: AWS::Serverless::Api
15 | Properties:
16 | StageName: v1
17 | Cors:
18 | AllowMethods: "'*'"
19 | AllowHeaders: "'*'"
20 | AllowOrigin: "'*'"
21 | Auth:
22 | Authorizers:
23 | CognitoAuthorizer:
24 | UserPoolArn:
25 | Fn::Sub: arn:aws:cognito-idp:${AWS::Region}:${AWS::AccountId}:userpool/${UserPoolId}
26 |
27 | Worker:
28 | Type: AWS::Serverless::Function
29 | Properties:
30 | Handler: CustomerList::CustomerList.Functions::Handler
31 | Runtime: dotnetcore3.1
32 | Timeout: 10
33 | MemorySize: 256
34 | Tracing: Active
35 | AutoPublishAlias: live
36 | CodeUri: ./bin/Release/netcoreapp3.1/publish
37 | Events:
38 | Get:
39 | Type: Api
40 | Properties:
41 | Path: /
42 | RestApiId: !Ref ServiceApi
43 | Method: GET
44 | Auth:
45 | Authorizer: CognitoAuthorizer
46 | Environment:
47 | Variables:
48 | ASPNETCORE_ENVIRONMENT:
49 | Fn::Sub: "${ASPNETCOREENVIRONMENT}"
50 | Policies:
51 | - Version: '2012-10-17'
52 | Statement:
53 | - Action: cognito-idp:*
54 | Effect: Allow
55 | Resource:
56 | - Fn::Sub: arn:aws:cognito-idp:${AWS::Region}:${AWS::AccountId}:userpool/${UserPoolId}
--------------------------------------------------------------------------------
/lab-4-alltogether/Customers.cshtml:
--------------------------------------------------------------------------------
1 | @*
2 | Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | SPDX-License-Identifier: MIT-0
4 | *@
5 |
6 | @page
7 | @model CustomersModel
8 | @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
9 | @{
10 | Layout = "_Layout";
11 | ViewData["Title"] = "Customers List";
12 | }
13 |
14 | @ViewData["Title"]
15 | 16 |17 |
18 | Table update at: @DateTime.UtcNow UTC
19 |
20 |
21 | 22 | @ViewData["Message"] 23 | 24 | @section Scripts 25 | { 26 | 27 | 28 | 29 | 56 | } -------------------------------------------------------------------------------- /lab-4-alltogether/Customers.cshtml.cs: -------------------------------------------------------------------------------- 1 | // Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | // SPDX-License-Identifier: MIT-0 3 | 4 | using System; 5 | using System.Collections.Generic; 6 | using System.IdentityModel.Tokens.Jwt; 7 | using System.Linq; 8 | using System.Net; 9 | using System.Threading.Tasks; 10 | using Amazon.CognitoIdentityProvider; 11 | using Amazon.S3; 12 | using Microsoft.AspNetCore.Authentication; 13 | using Microsoft.AspNetCore.Authentication.Cookies; 14 | using Microsoft.AspNetCore.Authentication.OpenIdConnect; 15 | using Microsoft.AspNetCore.Mvc; 16 | using Microsoft.AspNetCore.Mvc.RazorPages; 17 | using Microsoft.AspNetCore.Mvc.Rendering; 18 | using Microsoft.Extensions.Configuration; 19 | using Microsoft.Extensions.Logging; 20 | using Microsoft.Extensions.Logging.Debug; 21 | 22 | 23 | namespace WebApp.Pages 24 | { 25 | public class CustomersModel : PageModel 26 | { 27 | private readonly ILogger _logger; 28 | 29 | public CustomersModel(ILogger
14 |
15 | 3. Download the [Customers.cshtml](Customers.cshtml) file and copy its content to the newly created **Customers.cshtml**. Repeat the step for the [Customers.cshtml.cs](Customers.cshtml.cs) file too. Both files are also accessible at the *lab-4-alltogether* directory in the repo.
16 |
17 | 4. Execute ```aws apigateway get-rest-apis --query 'items[*].{name:name,restApiId:id}'``` and search for the result that contains **-CustomerList** in its the name.
18 | 5. Open the **Customers.cshtml**. Go to line 40 and replace the **restApiId** value (obtained on the previous step). The excerpt below shows what to look for. Don't forget to replace the **awsRegion** with the aws region you are running the workshop.
19 | ```
20 | "ajax": {
21 | "url": "https://Congratulations!!! Your ASP.NET Core Web Application is now Serverless
40 | 41 |42 | @ViewData["Token"] 43 |
44 | 45 |46 | @ViewData["Message"] 47 |
48 | ``` 49 | 50 | 8. Compiles the new code to create the binaries that will be deployed. 51 | ``` 52 | dotnet publish -c Release 53 | ``` 54 | 9. Execute the following command: 55 | 56 | :notebook: **Note**: The [Support Commands Page](/SupportCommands.md) provides a list of useful commands that helps you identify the resources' names created during the labs executions;like the Amazon S3 bucked required for deployment. 57 | 58 | ```bash 59 | dotnet lambda deploy-serverless --template serverless.template --s3-bucket
77 |
78 | 4. Access the **Customers** page that calls the Customer List microservices by adding Customers at the URL:
79 | ```
80 | https://
83 |
84 | ## Step 3: Testing the Microservices API Authentication using an API testing tool
85 | In this step, we will access the DotNet CustomerList API directly to show how the API Authentication works. In the example below the tool utilized is [Postman](https://www.getpostman.com/)
86 |
87 | 1. Obtain the restApiId for the CustomerList microservices by executing ```aws apigateway get-rest-apis --query 'items[*].{name:name,restApiId:id}'``` and copy the **restApiId** that contains **-CustomerList** in the name.
88 |
89 | 2. From the AspNetCoreWebApp page (https://*restApiId*.execute-api.*awsRegion*.amazonaws.com/Prod/) copy the token from the initial page.
90 |
91 | 
92 |
93 | 3. Open the API tool of your choice and paste the https://*restApiId*.execute-api.*awsRegion*.amazonaws.com/v1 with the method **GET** and send the request. As the call hasn't provided any identity token, the result is an **Unauthorized** message.
94 |
95 | 
96 |
97 | 4. At this time, add a header key/pair value for authentication. Add a key called **Authorization** and its value being the **identity token** copied at step 3.6. When you submit the call, the result will be the json file with all the customer's information.
98 |
99 | 
100 |
101 | ***You have now completed this Lab and can move onto [Lab 5](../lab-5-xray/).***
102 |
--------------------------------------------------------------------------------
/lab-5-xray/README.md:
--------------------------------------------------------------------------------
1 | # Lab 5: Improving monitoring with x-Ray
2 |
3 | [AWS X-Ray](https://aws.amazon.com/xray/) traces user requests as they travel through your entire application. In this Lab, we will add X-Ray to the AWS Lambda functions. We will also enable it at the Amazon API Gateway to enrich the traceability. You can find more information about the AWS X-Ray SDK for .Net and .Net Core [here](https://github.com/aws/aws-xray-sdk-dotnet).
4 |
5 | ## Step 1: Enabling AWS X-Ray for Amazon API Gateway
6 |
7 | 1. Let's once again get the restApiId for the CustomerList microservices and AspNetCoreApp. Use Amazon Api Gateway [Support Commands Page](/SupportCommands.md) to obtain the **restApiId** that contains **AspNetCoreWebApp** and **CustomerList** in the their name.
8 |
9 | 2. Execute the following commands to enable logging and tracing with the *AspNetCoreWebApp* **restApiId** pointing to the *Prod* Stage.
10 | ```
11 | aws apigateway update-stage --rest-api-id 
71 |
72 | 7. The table now shows the analytics per user.
73 |
74 | ***You have now completed this Lab and can move onto [Lab 99](../lab-99-cleanup/).***
75 |
--------------------------------------------------------------------------------
/lab-99-cleanup/README.md:
--------------------------------------------------------------------------------
1 | # Lab 99: Clean-up
2 |
3 | ## Step 1: Removing files from Amazon S3
4 |
5 | :notebook: **Note**: The [Support Commands Page](/SupportCommands.md) provides a list of useful commands that help you identify the names of the resources created in the labs, as the Amazon S3 bucked required for deployment.
6 |
7 | 1. recursively deletes all objects under a bucket, for when deleting the Cloudformation Stack the bucket can be successfully deleted. If a bucket has objects, it won't get deleted.
8 | ```
9 | aws s3 rm s3://