https://github.com/int128/hello-sam
Hello AWS SAM
https://github.com/int128/hello-sam
aws-lambda aws-sam
Last synced: about 2 months ago
JSON representation
Hello AWS SAM
- Host: GitHub
- URL: https://github.com/int128/hello-sam
- Owner: int128
- Created: 2018-07-07T06:57:32.000Z (about 7 years ago)
- Default Branch: master
- Last Pushed: 2020-07-04T12:44:01.000Z (over 5 years ago)
- Last Synced: 2024-10-27T08:53:34.846Z (11 months ago)
- Topics: aws-lambda, aws-sam
- Language: JavaScript
- Size: 25.4 KB
- Stars: 2
- Watchers: 3
- Forks: 5
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Hello AWS SAM
An example on AWS SAM.
This sends the following events to the Slack channel:
- API Gateway
- SNS
## Getting Started
Prerequisite:
- You have an AWS account.
- You have configured your IAM access key.
Then create a bucket.
```sh
export AWS_PROFILE=hello
make bucket
```
### Build a stack
Deploy:
```sh
make deploy
```
You can see progress on https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks
After deployment:
1. Set up a Slack Incoming Webhook.
1. Set `SLACK_WEBHOOK` variable on https://console.aws.amazon.com/lambda/home?region=us-east-1
You can see log on https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logs:
### Destroy the stack
```sh
make destroy
```
----
This is a sample template for sam-app - Below is a brief explanation of what we have generated for you:
```bash
.
├── README.md <-- This instructions file
├── hello_world <-- Source code for a lambda function
│ ├── app.js <-- Lambda function code
│ ├── package.json <-- NodeJS dependencies
│ └── tests <-- Unit tests
│ └── unit
│ └── test_handler.js
└── template.yaml <-- SAM template
```
## Requirements
* AWS CLI already configured with at least PowerUser permission
* [NodeJS 8.10+ installed](https://nodejs.org/en/download/)
* [Docker installed](https://www.docker.com/community-edition)
## Setup process
### Installing dependencies
In this example we use `npm` but you can use `yarn` if you prefer to manage NodeJS dependencies:
```bash
cd hello_world
npm install
cd ../
```
### Local development
**Invoking function locally through local API Gateway**
```bash
sam local start-api
```
If the previous command ran successfully you should now be able to hit the following local endpoint to invoke your function `http://localhost:3000/hello`
**SAM CLI** is used to emulate both Lambda and API Gateway locally and uses our `template.yaml` to understand how to bootstrap this environment (runtime, where the source code is, etc.) - The following excerpt is what the CLI will read in order to initialize an API and its routes:
```yaml
...
Events:
HelloWorld:
Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
Properties:
Path: /hello
Method: get
```
## Packaging and deployment
AWS Lambda NodeJS runtime requires a flat folder with all dependencies including the application. SAM will use `CodeUri` property to know where to look up for both application and dependencies:
```yaml
...
FirstFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
...
```
Firstly, we need a `S3 bucket` where we can upload our Lambda functions packaged as ZIP before we deploy anything - If you don't have a S3 bucket to store code artifacts then this is a good time to create one:
```bash
aws s3 mb s3://BUCKET_NAME
```
Next, run the following command to package our Lambda function to S3:
```bash
sam package \
--template-file template.yaml \
--output-template-file packaged.yaml \
--s3-bucket REPLACE_THIS_WITH_YOUR_S3_BUCKET_NAME
```
Next, the following command will create a Cloudformation Stack and deploy your SAM resources.
```bash
sam deploy \
--template-file packaged.yaml \
--stack-name sam-app \
--capabilities CAPABILITY_IAM
```
> **See [Serverless Application Model (SAM) HOWTO Guide](https://github.com/awslabs/serverless-application-model/blob/master/HOWTO.md) for more details in how to get started.**
After deployment is complete you can run the following command to retrieve the API Gateway Endpoint URL:
```bash
aws cloudformation describe-stacks \
--stack-name sam-app \
--query 'Stacks[].Outputs'
```
## Testing
We use `jest` for testing our code and it is already added in `package.json` under `scripts`, so that we can simply run the following command to run our tests:
```bash
cd hello_world
npm run test
```
# Appendix
## AWS CLI commands
AWS CLI commands to package, deploy and describe outputs defined within the cloudformation stack:
```bash
sam package \
--template-file template.yaml \
--output-template-file packaged.yaml \
--s3-bucket REPLACE_THIS_WITH_YOUR_S3_BUCKET_NAME
sam deploy \
--template-file packaged.yaml \
--stack-name sam-app \
--capabilities CAPABILITY_IAM \
--parameter-overrides MyParameterSample=MySampleValue
aws cloudformation describe-stacks \
--stack-name sam-app --query 'Stacks[].Outputs'
```
**NOTE**: Alternatively this could be part of package.json scripts section.
## Bringing to the next level
Here are a few ideas that you can use to get more acquainted as to how this overall process works:
* Create an additional API resource (e.g. /hello/{proxy+}) and return the name requested through this new path
* Update unit test to capture that
* Package & Deploy
Next, you can use the following resources to know more about beyond hello world samples and how others structure their Serverless applications:
* [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/)