Merge pull request #4 from Niicck/serverless

feat(scripts) - enable automated AWS deployments using serverless.js

Author: benjie

.env.template

@@ -2,5 +2,10 @@ export POSTGRES_USER="forum_example_postgraphile"
 export POSTGRES_PASSWORD="xyz"
 export POSTGRES_DB="forum_example_postgraphile"
 export DATABASE_SCHEMAS="forum_example"
-export DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost/${POSTGRES_DB}"
+export DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:5432/${POSTGRES_DB}"
 export JWT_SECRET="2c045e2eb2ec46488530"
+export JWT_PG_TYPE_IDENTIFIER="forum_example.jwt_token"
+
+export AWS_SERVICE_NAME="my-postgraphile-lambda"
+export AWS_REGION="us-east-1"
+export AWS_STAGE="dev"

.gitignore

@@ -4,3 +4,5 @@
 /dist
 /test/template.yml
 /lambda.zip
+/.serverless/
+.DS_Store

README.md

@@ -35,8 +35,9 @@ We use the following tools:
   during the build and write the results to a cache file to be included in the
   bundle; then when the Lambda service starts up it can read from the cache
   rather than introspecting the database again.
+- serverless.js (optional) - for automated AWS deployments.
 
-## Building lambda.zip
+## Setup
 
 First clone this repository locally, and install dependencies:
 
@@ -50,18 +51,29 @@ Next, set up a `.env` file matching your environment:
 cp .env.template .env
 ```
 
-And modify the `src/postgraphileOptions.js` file to your taste.
+And modify the `src/postgraphileOptions.js` and `serverless.yml` files to your taste.
 
-Finally run:
+## Automatic Deployment with Serverless.js
+
+#### Deployment Prerequisites
+
+- [serverless](https://serverless.com/framework/docs/providers/aws/guide/installation/) - `yarn global add serverless`
+
+After configuring your `.env` file, ~/.aws/credentials, and postgraphileOptions.js, you can deploy to AWS using serverless.js by running:
 
 ```
-yarn build
+yarn deploy
 ```
 
-This will result in a `lambda.zip` file that you can upload to Amazon Lambda.
+## Setting up a Lambda endpoint manually
+
+If you prefer not to use the serverless.js framework, you can also deploy your lambda function manually.
+
+Note 1: Change your process.env.AWS_STAGE_NAME to "/default" to match the default stage name for manually deployed API Gateways.
 
-## Setting up a Lambda endpoint
+Note 2: CORS is enabled by default. Remove cors() middleware in `/src/index.js` if you would prefer disabled cors.
 
+0. Run `yarn build` to create `lambda.zip` file that you can upload to Amazon Lambda.
 1. Visit https://console.aws.amazon.com/lambda/home and click 'Create function'
 2. Select "Author from scratch" and give your function a name, select the most recent Node.js release (at least 8.10+), create (or select) a role (I granted "Simple microservice permissions")
 3. Click "Create function" and wait about 15 seconds; you should be greeted with a "Congratulations" message.
@@ -171,7 +183,7 @@ Do the same as for the test, but instead of running `yarn test` at the end, inst
 yarn sam
 ```
 
-This will set up a local GraphQL endpoint at http://127.0.0.1:3000/
+This will set up a local GraphQL endpoint at http://127.0.0.1:3000/graphql
 
 You can then use a GraphQL client such as Altair or GraphQL Playground to issue requests.
 

package.json

@@ -7,16 +7,19 @@
     "phase4": ". ./.env && scripts/test",
     "build": ". ./.env && scripts/build && scripts/generate-cache && scripts/bundle",
     "sam": ". ./.env && scripts/build && scripts/generate-cache && scripts/bundle && scripts/sam",
-    "test": ". ./.env && scripts/build && scripts/generate-cache && scripts/bundle && scripts/test"
+    "test": ". ./.env && scripts/build && scripts/generate-cache && scripts/bundle && scripts/test",
+    "deploy": "scripts/serverless"
   },
   "dependencies": {
-    "aws-serverless-express": "3.1.3",
+    "aws-serverless-express": "^3.3.5",
     "cors": "^2.8.5",
     "pg": "7.4.1",
     "postgraphile": "v4.2",
     "postgraphile-core": "^4.2.0"
   },
   "devDependencies": {
+    "aws-sdk": "^2.389.0",
+    "serverless-content-encoding": "^1.1.0",
     "webpack": "4.17.2",
     "webpack-cli": "3.1.0"
   }

scripts/createS3Bucket.js

@@ -0,0 +1,24 @@
+const aws = require('aws-sdk');
+const s3 = new aws.S3();
+
+const bucketName = process.env.AWS_SERVICE_NAME;
+
+async function main() {
+  const { Buckets } = await s3.listBuckets().promise();
+
+  if (Buckets.find(bucket => bucket.Name === bucketName)) {
+    console.log(`Bucket "${bucketName}" already exists.`);
+  } else {
+    const bucketParams = {
+      Bucket: bucketName
+    };
+
+    await s3.createBucket(bucketParams).promise();
+    console.log(`Bucket "${bucketName}" created.`);
+  }
+};
+
+main().catch(err => {
+  console.log('Error', err);
+  process.exit(1);
+});

scripts/serverless

@@ -0,0 +1,45 @@
+#!/bin/bash
+set -e
+CURRENT_DIR=`dirname $BASH_SOURCE`
+
+# Source env variables
+echo "Sourcing environment"
+if [ -x .env ]; then
+  . ./.env
+  echo "... done"
+else
+  echo "... no executable .env file found"
+fi
+
+if [ "$DATABASE_URL" = "" ]; then
+  echo "No DATABASE_URL envvar found; cannot continue."
+  exit 1
+fi
+
+rm -rf $CURRENT_DIR/../.serverless
+
+echo "Phase 1: Create serverless package"
+sls package
+
+echo "Phase 2: Build webpack bundle and add it to serverless package"
+scripts/build
+scripts/generate-cache
+scripts/bundle
+mv $CURRENT_DIR/../lambda.zip $CURRENT_DIR/../.serverless/graphql.zip
+
+# Update SHA hash for modified function zip file
+SHA=$(openssl dgst -sha256 -binary $CURRENT_DIR/../.serverless/graphql.zip | openssl enc -base64 | sed -e "s#/#\\\/#g")
+if [ $(uname -s) == 'Darwin' ]; then
+  # OSX sed syntax is slightly different
+  sed -i '' -e "s/\"CodeSha256\": \".*\"/\"CodeSha256\": \"${SHA}\"/g" $CURRENT_DIR/../.serverless/*.json
+else
+  sed -i "s/\"CodeSha256\": \".*\"/\"CodeSha256\": \"${SHA}\"/g" $CURRENT_DIR/../.serverless/*.json
+fi
+
+echo "Phase 3: Create S3 Bucket for serverless function"
+node scripts/createS3Bucket.js
+
+echo "Phase 4: Deploy package to AWS"
+sls deploy -p .serverless
+
+echo "Complete"

serverless.yml

@@ -0,0 +1,32 @@
+service: ${env:AWS_SERVICE_NAME}
+
+plugins:
+  - serverless-content-encoding
+
+custom:
+  contentEncoding:
+    minimumCompressionSize: 0
+
+package:
+  individually: true
+
+provider:
+  name: aws
+  runtime: nodejs8.10
+  deploymentBucket:
+    name: ${env:AWS_SERVICE_NAME}
+  region: ${env:AWS_REGION}
+  stage: ${env:AWS_STAGE}
+
+functions:
+  graphql:
+    handler: index.handler # Actual handler substituted in during deploy script
+    events:
+      - http:
+          method: post
+          path: graphql
+          cors: true
+          integration: lambda-proxy
+    environment:
+      DATABASE_URL: ${env:DATABASE_URL}
+      DATABASE_SCHEMAS: ${env:DATABASE_SCHEMAS}

src/index.js

@@ -1,8 +1,8 @@
 const awsServerlessExpress = require('aws-serverless-express');
-const cors = require('cors');
 const { postgraphile } = require('postgraphile');
 const { options } = require('./postgraphileOptions');
 const combineMiddlewares = require('./combineMiddlewares');
+const cors = require('cors');
 
 const schemas = process.env.DATABASE_SCHEMAS
   ? process.env.DATABASE_SCHEMAS.split(',')
@@ -14,10 +14,10 @@ const app = combineMiddlewares([
    *
    * This is typically useful for augmenting the request before it goes to PostGraphile.
    */
-  
+ 
   // CORS middleware to permit cross-site API requests. Configure to taste
   cors(),
-  
+
   // Determines the effective URL we are at if `absoluteRoutes` is set
   (req, res, next) => {
     if (options.absoluteRoutes) {
@@ -34,7 +34,6 @@ const app = combineMiddlewares([
     next();
   },
   postgraphile(process.env.DATABASE_URL, schemas, {
-    graphqlRoute: '/',
     ...options,
     readCache: `${__dirname}/postgraphile.cache`,
   }),

src/postgraphileOptions.js

@@ -2,18 +2,18 @@ exports.options = {
   dynamicJson: true,
   cors: true,
   graphiql: false,
-  externalUrlBase: '/default',
+  graphqlRoute: '/graphql',
+  externalUrlBase: `/${process.env.AWS_STAGE}`,
 
   // If consuming JWT:
   jwtSecret: process.env.JWT_SECRET || String(Math.random()),
   // If generating JWT:
-  jwtPgTypeIdentifier: 'forum_example.jwt_token',
+  jwtPgTypeIdentifier: process.env.JWT_PG_TYPE_IDENTIFIER,
 
   /* If you want to enable GraphiQL, you must use `externalUrlBase` so PostGraphile
    * knows where to tell the browser to find the assets.  Doing this is
    * strongly discouraged, you should use an external GraphQL client instead.
 
-    externalUrlBase: '/default',
     graphiql: true,
     enhanceGraphiql: true,
     graphqlRoute: '/',

test/make-template-yml.sh

@@ -23,12 +23,12 @@ Resources:
         Api:
           Type: Api
           Properties:
-            Path: /
+            Path: /graphql
             Method: post
         OptionsRoute:
           Type: Api
           Properties:
-            Path: /
+            Path: /graphql
             Method: options
         Favicon:
           Type: Api