GraphQL backend with AWS AppSync & AWS Lambda

© 2019, Amazon Web Services, Inc. or its Affiliates.© 2019, Amazon Web Services, Inc. or its Affiliates.
Sergey Pugachev
GraphQL backend with
AWS AppSync & AWS Lambda
Solutions Architect, AWS

© 2019, Amazon Web Services, Inc. or its affiliates. All rights reserved.
Fullstack
https://www.flickr.com/photos/ginnerobot/2549674908/

Backend
Front end
CI/CD
https://www.flickr.com/photos/ginnerobot/2549674908/

No servers to provision
or manage
Scales with usage
Never pay for idle Availability and fault
tolerance built in
Serverless means…

© 2019, Amazon Web Services, Inc. or its Affiliates. All rights reserved.
Cloud Services
Cloud
Less More
Compute Virtual Machine
EC2 Elastic Beanstalk AWS LambdaFargate
Databases MySQL MySQL on EC2
RDS MySQL RDS Aurora Aurora Serverless DynamoDB
Storage Storage
S3
Messaging ESBs
Amazon MQ Kinesis SQS / SNS
Analytics
Hadoop Hadoop on EC2 EMR Elasticsearch Service Athena

Docker orchestration in the cloud
Management
Hosting
Amazon Elastic
Container Service
Amazon Elastic
Kubernetes Service
Amazon EC2 AWS Fargate
Image Registry Amazon Elastic
Container Registry

Upstream Kubernetes
Use standard Kubernetes APIs.
Works with community tools.
Highly available
Built for production workloads, all clusters are highly
available. Backed by a 99.9% SLA.
Integrated
with the AWS ecosystem: VPC Networking, Elastic Load
Balancing, IAM Permissions, CloudWatch and more
Amazon Elastic Kubernetes Service

Managed by AWS
No EC2 Instances to provision, scale or manage
Elastic
Scale up & down seamlessly. Pay only for what you use
Integrated
with the AWS ecosystem: VPC Networking, Elastic Load
Balancing, IAM Permissions, CloudWatch and more. Run
Kubernetes pods or ECS tasks.
AWS Fargate

{API}

InternetMobile &
web apps
Databases &
data stores
Basic API technology stack
Failover
Load balancers
Web & application servers
Message buses
Workers
?API
backend
?API
“server”

AWS
InternetMobile &
web apps
Databases &
data stores
Basic API technology stack
Failover
Load balancers
Web & application servers
Message buses
Workers
?API
backend
?API
“server”

InternetMobile &
web apps
Basic serverless API technology stack
AWS
Serverless
business logic
Serverless
APIs
Databases &
data stores
Fail over
Load balancers
Web/application servers
Message buses
Workers

/posts /comments /authors
REST API
posts comments authors
GraphQL API
What is GraphQL?

Queries MutationsTypes
Subscriptions
GraphQL schema and operations
A query language for APIs . . . and a runtime!
type User {
id: ID!
username: String!
firstName: String
lastName: String
daysActive: Int
}

Queries
query GetPost {
getPost(id: ”1”) {
id
title
}
}
mutation CreatePost {
createPost(title: “Summit”) {
id
title
}
}
subscription OnCreatePost {
onCreatePost {
id
title
}
}
Mutations Subscriptions
A query language for APIs . . .

AWS AppSync
Managed serverless
GraphQL service
Connect to data
sources in your account
Add data sync, real-time, and
offline capabilities for any data
source or API
GraphQL facade for any
AWS service
Conflict detection and
resolution in the cloud
Enterprise security features:
IAM, Amazon Cognito, OIDC,
API keys

How does AWS AppSync work?
,
,

GraphQL data flow in AWS AppSync: Resolvers
Request template Response template
Data sources
1 2 3 4 5

Pipeline resolvers

Real-time data broadcasting

Real-time subscriptions
subscription onCreateMessage {
createMessage {…}
}
WebSocket URL and connection payload
Secure WebSocket connection (wss://)
AppSync Data Sources
AWS AppSync
Amazon
DynamoDB
Amazon Elasticsearch
Service
AWS Lambda
Amazon Aurora
HTTP
Local (Pub/Sub)

Offline

Polyglot backend data access

Amplify Framework

Amplify Framework
ü CLI
ü Client libraries (native and JS support)
ü Console – Continuous deployment
and hosting
ü Prebuilt UI components
ü Toolchain
ü JS framework support

• Create, update, and delete cloud services
• Manage multiple environments
• GraphQL Transform
• GraphQL Codegen
Amplify Framework
CLI

Categories
Authentication
Analytics
Interactions (chat bots)
API (REST)
API (GraphQL)
Amplify CLI
Serverless functions
Storage
XR
Push notifications
Video

$ amplify add auth
$ amplify push
$ amplify configure auth
$ amplify delete
$ amplify codegen add
Amplify CLI

$ amplify add api
–
# schema.graphql
type Post @model {
id: ID!
title: String!
}

@model
Top-level entity; creates DynamoDB table, resolvers, and additional schema (queries,
mutations, and subscriptions) for base type
@connection
Enables relationships between @model types
@auth
Enables set of authorization rules
@searchable
Handles streaming the data of an @model object type to Amazon Elasticsearch Service
and configures search resolvers
@versioned
Enables versioning
@function
Enables adding a Lambda function as a data source
–

GraphQL Transform: Mix and match data sources
type Post {
id: ID!
content: String
description: String
ups: Int
downs: Int
}

createPost
readPost
updatePost
deletePost
type Post
@model {
id: ID!
content: String
description: String
ups: Int
downs: Int
}

mutations
queries
createPost
readPost
updatePost
deletePost
type Post
@model
@auth(rules: [{allow:
owner}]){
id: ID!
content: String
description: String
ups: Int
downs: Int
}

searchPosts
mutations
queries
createPost
readPost
updatePost
deletePost
type Post
@model
@auth(rules: [{allow: owner}])
@searchable{
id: ID!
content: String
description: String
ups: Int
downs: Int
}

searchPosts
mutations
queries
createPost
readPost
updatePost
deletePost
type Post
@model
@auth(rules: [{allow:
owner}])
@searchable{
id: ID!
content: String
description: String
ups: Int
downs: Int
}

$ amplify add codegen [--apiId <api-id>]
// Will generate GraphQL statements
// (queries, mutations, subscriptions)

$ amplify env add
$ amplify env list
$ amplify env checkout
$ amplify env remove

Multiple environments and team workflow
• Git-style interaction and project switching
• Share backends between team members or clone for sandbox isolated development
User Users

Amplify Framework
• Connect to and interact with cloud services from web and mobile
applications
• Preconfigured components for popular front-end libraries
Client

AWS Amplify client
• Opinionated
• Declarative
• Client focused
• High-level abstractions
• Best practices built in
• Built with Amplify CLI in mind

AWS Amplify client
import {
Auth, API, Storage, Analytics, XR
} from ‘aws-amplify’
$ npm install aws-amplify

AWS Amplify client
import {
Auth
} from ‘aws-amplify’
Auth.signIn(’myusername’, ‘mypassword’)
Auth.signOut()
Auth.currentAuthenticatedUser()

AWS Amplify: Native support

AWS Amplify: JS framework support

Higher-order components
import {withAuthenticator} from ‘aws-amplify-react’
export default withAuthenticator(App)
class App extends Component {
// your code goes here

Amazon API Gateway
Amazon Pinpoint
AWS Lambda
AWS AppSync Amazon DynamoDBAmazon Cognito

Deploying a Lambda function with API Gateway
1. Create the Lambda function & API
$ amplify add api
// chose REST with Express backend

2. Write code/make changes
// amplify/backend/function/<FUNCTION_NAME>/src/app.js
app.get(‘/items’, function(req, res) {
// new code goes here
})

$ amplify push
3. Deploy new API
Amazon API Gateway AWS Lambda

import { API } from ‘aws-amplify’
API.get(’/items’)
.then(data => console.log({ data }))
.catch(err => console.log({ err })
4. Interact with the API

$ amplify add auth
// choose either default or custom configuration
1. Create the authentication service
Adding authentication

import { Auth } from ‘aws-amplify’
2. Import the Auth component

Auth.signUp(‘username’, ‘password’, {
attributes: { email: ‘jane@doe.com’ }
})
Auth.signIn(’myusername’, ‘mypassword’)
3. Implement Auth methods

$ amplify add api
// chose GraphQL
1. Create the GraphQL API
Deploying a GraphQL API

type Todo @model {
id: ID!
name: String!
description: String!
completed: Boolean
}
2. Define annotated GraphQL schema

$ amplify push
3. Deploy new API
Amazon Cognito AWS AppSync Amazon DynamoDB

import { API, GraphqlOperation } from ‘aws-amplify’
import { listTodos } from ‘./src/graphql/queries’
API.graphql(graphqlOperation(listTodos))
.then(data => console.log({ data }))
.catch(err => console.log({ err })
4. Interact with API

$ amplify add analytics
$ amplify push
1. Create analytics service
Adding analytics
Amazon Pinpoint

2. Import Analytics API
Adding analytics
import { Analytics } from ‘aws-amplify’

3. Record events
Adding analytics
Analytics.record({ name: 'albumVisit’ })
Analytics.record({
name: 'albumVisit', // Attribute values must be strings
attributes: { genre: ‘nu-metal', artist: ’RATM’ }
})

AWS AppSync JS SDK
• Offline ready
• Built-in helpers for optimistic response,
subscriptions
• Use with React Apollo / Vue Apollo /
Angular Apollo
• https://github.com/awslabs/aws-mobile-appsync-sdk-js

Fullstack DevOps for web apps
• Strong isolation barrier between projects and stages
Dedicated AWS accounts for each project and stage (sandbox, staging, prod)
• Source code (and history) for each stage readily available
Git branching used for the source code for each stage
• Minimize version mismatches between front end and backend
Front end (e.g., code) and backend (e.g., AWS CloudFormation templates)
developed and versioned together in same Git repository
• Developers in control
Developers deploy front end *and* backend

DevOps requirements for modern web apps
Web app
per dev
sandbox
Test web app Prod web app
Isolated
backends
Shared backend

DevOps challenges with modern web apps
Lots of moving parts complicate the following:

AWS Amplify Console
Build, deploy, and host cloud-powered modern web apps
Optional deployment of backend resources +
fully managed front-end hosting

Use cases
Use static site generators like Hugo or Jekyll
to publish a blog. SSGs perform faster than
traditional websites. Deploy SSGs with free
SSL on the AWS Amplify Console.
Add dynamic functionality using GraphQL or
REST APIs. Use the AWS Amplify Console to
deploy your front end and backend in a single
workflow.
PWAs offer native app-like performance, work
offline, support push notifications, and can be
updated over the air. Use AWS Amplify to
deploy PWAs to mobile devices.

© 2019, Amazon Web Services, Inc. or its affiliates. All rights reserved.© 2019, Amazon Web Services, Inc. or its Affiliates.
Sergey Pugachev
GraphQL backend with
AWS AppSync & AWS Lambda
Solutions Architect, AWS

GraphQL backend with AWS AppSync & AWS Lambda

More Related Content

Similar to GraphQL backend with AWS AppSync & AWS Lambda (20)

More from Aleksandr Maklakov (14)

Recently uploaded (20)

GraphQL backend with AWS AppSync & AWS Lambda