Serverless Microservices on AWS in 10 Hours

Name: Serverless Microservices on AWS in 10 Hours
Rating: 4.0 (72 reviews)

The perfect course to implementing cost-effective, and scalable Microservices and APIs using serverless computing on AWS

Created byPackt Publishing

Last updated 11/2018

English

What you'll learn

Improve the reusability, composability, and maintainability of code
Create a highly available serverless microservice data API
Build, deploy and run your serverless configuration and code
Implement over 15 microservices architecture patterns without needing containers or EC2 instances
Speed up delivery, flexibility and time to market using serverless microservices
Add your microservices to a continuous integration & continuous delivery pipeline

Course content

2 sections • 65 lectures • 10h 2m total length

The Course Overview9:34
This video gives an overview of the entire course.
Monolithic and Microservice Architectures15:08
There are many architectures that exist before Microservices. In this video, we will see what are they, what are the benefits and drawbacks, how do they compare to microservices.
See the overview of monolithic multi-tier architecture and Service Orientated Architecture (SOA)
See the overview of micsoservices architecture
See the benefits and drawbacks of monolithic and micsoservices architecture
Virtual Machines, Containers, and Serverless Computing13:08
In this video, we will show where does serverless computing fit in with other public cloud offerings.
See the overview of virtual machines benefits and drawbacks
See the overview of container benefits and drawbacks
See the overview of serverless computing benefits and drawbacks
Serverless Computing in AWS10:38
In this video, we will see what the serverless computing offerings available in AWS are and how these service s fit together.
See the overview of the serverless managed services
See the example: how these can fit together to solve a data transformation task
Setting Up Your Serverless Environment in AWS11:21
In this video, we will set up a new user. Also, we will see how can I ensure that the user access is secure and how I setup my local serverless environment.
Use the AWS Management Console to setup a new user
Set up multi-factor authentication for a user
Set up your local environment credentials, AWS Python SDK and CLI
Overview of Security in AWS5:52
In this video, we will see that with data breaches and compliance requirements security is a key consideration.
See the security Examples and impacts on an organization
Explain the security at rest, in transit, authentication, and authorization
Learn that AWS has a shared security responsibility model that should be followed
Overview of AWS Identity and Access Management (IAM)3:24
In this video, we will see how can we configure AWS security to help secure user authorization and access to resources.
Explain AWS Identity and Access Management (IAM)
Learn IAM policies, users, groups to help secure your users
Explain IAM roles to help secure your trusted entity
Securing Your Serverless Microservice5:45
In this video, we will see how can we ensure that your microservice is secure and what are some of the best practices.
Explain Lambda security
Learn API gateway and DynamoDB security
Explain how to monitor and alert
Building a Serverless Microservice Data API6:56
In this video, we will see what is the architecture of serverless data provider API.
Make use of API gateway, Lambda, and DynamoDB
Overview of JSON and time series data
Explain about request/response data flows
Setting Up a Lambda in the AWS Management Console10:52
In this video, we will see how can I create my first Lambda function that parses the given URL parameters.
Setup the IAM policies and role
Write the Lambda code that parses the given URL parameters
Test the Lambda function works
Setting Up the API Gateway and Integrating It with a Lambda Proxy6:05
In this video, we will configure the API gateway to call a Lambda function.
Create the API gateway resources and method
Integrate the GET method with Lambda
Test the API invoked the Lambda function correctly
Creating and Writing to a NoSQL Database Called DynamoDB7:44
In this video, we will see how can I create, add data to, and query my DynamoDB table.
Create a DynamoDB table using boto3
Insert data into DynamoDB
Query DynamoDB by partition and sort keys
Creating a Lambda to Query DynamoDB3:17
In this video, we will see how can I query DynamoDB from within a Lambda function.
Add the previous Lambda code that parses the given URL parameters
Add the previous code that queries DynamoDB by Partition and sort keys
Test the Lambda function with sample request data
Connecting API Gateway, Lambda, and DynamoDB4:25
In this video, we will see how the API Gateway, Lambda and DynamoDB integrate together and is it all working.
Understanding the integration
Test the data with a request URL
Understand the overall serverless microservices API
Unit Testing Your Python Lambda Code9:10
In this video, we will see how we can make sure that the code is still running correctly and be more productive writing Lambda code.
See that testing allows better collaboration, improves product quality, and leads to shorter release cycles
Explain how unit tests help to verify that our functions work as expected
Mock to replace parts of the system under test
Running and Debugging Your AWS Lambda Code Locally4:08
In this video, we will see how can I simulate and debug a Lambda locally with real data without deploying it to AWS.
Use sample event data
Pass it into the Lambda function
Debug the Lambda code step by step
Integration Testing Using Real Test Data1:30
Once the Lambda function is deployed to AWS, this video explains how I can test it to make sure it’s running correctly.
Use sample event data
Submit the data via the AWS CLI
Make sure we get the expected response
Performance and End-to-End Testing at Scale6:17
In this video, we will see how I know if my API is performing as expected with a low latency and how can I improve the latency.
Use Python Locust tool
Load test for concurrent users
See that the latency can be improved by changing DynamoDB and Lambda settings
Overview of Serverless Stack Build and Deploy Options7:26
In this video, we will get to know that there are many challenges of provisioning infrastructure manually which include the cost, effort, lack of repeatable processes and limited scalability.
Use Infrastructure as a Code
Learn that serverless infrastructure and resources can be deployed using Serverless Application Model (SAM)
Learn that serverless infrastructure and resources can be deployed using the AWS CLI other frameworks
Creating an S3 Bucket, IAM Policies, and IAM Roles Resources4:08
In this video, we will get to know that resource and infrastructure need to be provisioned.
Create an S3 bucket for the Lambda deployment package
Deploy IAM policies for the Lambda function
Deploy IAM roles for the Lambda function
Building and Deploying API Gateway, Lambda, and DynamoDB10:10
In this video, we will see what are the steps needed to prepare and deploy the serverless stack.
Create a Lambda deployment package
Create API gateway, lambda, and dynamo using SAM
Load data into DynamoDB
Building a Scalable Serverless Microservice Data API Conclusions6:15
In this video, we’ll summarize what we have covered in this course.
Next Course3:00
In this video, we’ll have a quick look at what is going to be covered in the next course.
Test Your Knowledge

The Course Overview12:13
This video gives an overview of the entire course.
Overview of Microservice Integration Patterns7:55
In building serverless microservices how can we benefit from what is available from leading companies and open source communities.
Make use of design patterns
Use software design patterns and principles
Use and understand serverless microservice pattern categories
Communication Styles and Decomposition Microservice Patterns13:18
How do we ensure efficient communication between microservices? How are microservices created and designed?
Understand synchronous versus asynchronous communication
Understand one-to-one and many-to-many communication microservice patterns
Understand decomposition pattern by business capability
Serverless Computing to Implement Microservice Patterns8:06
What are the serverless microservice patterns that can leverage in AWS to reduce development, maintenance, and running costs?
Understand lambda event sources types
Understand lambda stream event sources
Leverage AWS managed services and serverless offerings in each category and use case
Implementing Database Per Service and Shared Database Patterns12:08
Lambda functions are stateless, so you need to store state externally which is best practice. What is important in distributed systems and what are the best ways to store state?
Understand that CAP Theorem stands for Consistency, Availability, and Partition tolerance and is important for data storage in distributed systems
Understand the shared database and database per service patterns, and how they are used in distributed systems
Understand how these patterns can be implemented with DynamoDB, RDS, Aurora or Aurora serverless
Accessing DynamoDB from API Gateway Via a Lambda Function13:24
How can we expose data in DynamoDB externally?
Use API Gateway and a lambda function as a proxy
Create API methods such as GET and POST
Use the lambda function to shape the request into a DynamoDB query and parse the returned data for the API
Accessing DynamoDB Directly from API Gateway11:50
Is there a simpler way to expose DynamoDB data externally?
Use API gateway direct DynamoDB integration
Use API gateway to shape the query in the integration request step
Use API gateway to shape the response in the integration response step
Implementing the Transaction Log Tailing Pattern13:02
How can I implement the transaction log trailing pattern?
Use DynamoDB streams
Use a lambda function to consume the stream as an event source
Use a lambda to write the steam data to another table in DynamoDB
Implementing the Saga Pattern12:34
How can I implement the saga pattern as a serverless stack?
Use SNS and lambda combination
Use step functions to build up a state machine in JSON using the Amazon states language
Use step functions states to invoke lambda functions
Securing Your DynamoDB Databases7:27
How can I ensure that my DynamoDB database is secure?
Enable encryption at rest
Enable the VPC endpoint
Use IAM policies that are locked down as much as possible to a specific table and with minimum permissions
Relational Versus Non-Relational Databases13:30
What are the main differences between relational and non-relational databases?
Understand the BASE versus ACID consistency models
Understand the scalability for non-relational databases
Understand SQL flexibility for relational databases
Overview of Amazon Virtual Private Cloud8:15
What is a VPC and why is it needed?
Understand VPC is a virtual network isolated from other networks
Understand that a VPC contains one or more Subnets
You have to use a VPC to access RDS or Aurora from a Lambda function
Setting Up Amazon Virtual Private Cloud for Accessing RDS and Aurora5:28
What are the main steps for setting up a VPC?
Create VPC and subnets
Attach an internet gateway and Egress only gateway
Configure the to route tables and associate it with the subnets
Setting Up RDS and Accessing It from Your Local Network5:43
What are the main steps to look out for when accessing RDS from your local network?
Configure you corporate or local firewall
Configure the route tables with your IP
Configure the VPC security groups with your IP
Accessing RDS from API Gateway Via a Lambda Function12:35
Why and how can a lambda access an RDS instance?
Access MySQL RDS from API gateway via a lambda function
Understand the code and configuration to set it up
Ensure the lambda role has a policy that allows it to attach and detach network interfaces within a VPC
Accessing Aurora from API Gateway Via a Lambda Function12:01
What are the main differences for a lambda to access Aurora over RDS MySQL?
Use the same code to access MySQL RDS, MySQL Aurora, and Aurora Serverless
Understand that Aurora is clustered by default
Understand the additional read replica database endpoint in Aurora
Securing Your RDS and Aurora Databases14:20
What are the main steps to ensure your RDS or Aurora databases communication is secure?
Understand RDS and Aurora encryption in transit code and configuration
Set up RDS or Aurora IAM database authentication
Use IAM database authentication to generate an authorization token rather than use a password
API Gateway and API Composition Patterns6:15
We need a way to create an efficient API that can be consumed by third parties and abstract away the underlying complexities.
Understand API Gateway Pattern
Understand API Composition Pattern
Understand the benefits and drawback of API Composition Pattern
Implementing the Serverless API Composition Patterns6:12
What can we use to implement the API gateway and API composition patterns?
Understand Amazon Route 53 and use it as a sclable cloud DNS
Understand implement Amazon API Gateway and AWS Lambda
Use Amazon CloudFront and Amazon S3
Event Sourcing and CQRS Patterns11:47
How can we overcome the database persistence limitation such as lack of full history on row changes, and efficient distributed synchronisation/replication challenges?
Use the event sourcing pattern where every action is an event appended to an event store
Use the Command Query Responsibility Segregation (CQRS) pattern to split write and read methods
Understand that in CQRS, commands are methods that mutates state and queries are methods that return data
Architectures of the Serverless Event Sourcing Pattern9:04
What AWS managed services are core to architect the serverless event sourcing pattern?
Use Amazon Kinesis streams
Use Amazon DynamoDB
Use Amazon SQS
Implementing the Serverless Event Sourcing Pattern10:53
How can we implement the serverless event sourcing pattern?
Have API Gateway with or without a lambda proxy write to DynamoDB
Have API Gateway with or without a lambda proxy write to Kinesis Streams
Have API Gateway with or without a lambda proxy write to SNS or SQS. The lambda the uses CloudWatch trigger
Architectures of the Serverless CQRS Pattern11:35
What AWS managed services are core to architect a serverless CQRS pattern?
Use Aurora, Aurora Serverless, or DynamoDB
Use SQS / SNS
Use Kinesis Streams and Kinesis Firehose
Implementing the Serverless CQRS Pattern9:38
How can we implement the serverless CQRS pattern command and event processor?
Have API gateway with or without a lambda proxy write to DynamoDB. Then a lambda writes to DynamoDB and Kinesis Firehose
Have API gateway with or without a lambda proxy write to SQS/SNS. Then a lambda writes to DynamoDB and Kinesis Firehose
Have API gateway with or without a lambda proxy write to Kinesis Streams. Then a Lambda writes to DynamoDB and Kinesis Streams write to Kinesis Firehose
Securing Your Event Streams and Queries8:09
How can we secure the serverless resources?
Use roles specific to the resource
Attach policies to the role
Specify the permitted actions on the resources in the policy
Monitoring and Observability Patterns9:10
Why is it important to monitor your microservices and what patterns are available to do so?
1000s of microservices, governance, compliance, operational auditing, risk auditing, and so on
Use application metrics and health checks patterns
Use centralized logging, audit logging, and distributed tracing patterns
Implementing Serverless Metrics and Health Check API Patterns11:13
How can serverless application metrics and health check API patterns be implemented?
Use Amazon CloudWatch
Use a lambda triggered by CloudWatch to run health checks
Use a lambda to write the results of the check to CloudWatch metrics and set an Alarm that sends an email notification upon failure
Implementing the Serverless Centralized Logging Pattern10:20
What are the different ways to send logs to CloudWatch logs?
Use API Gateway built-in logging or custom logging
Use Lambda print function, native logging or external JSON logging packages
For non-lambda microservice (e.g. traditional EC2 or container-based) use CloudWatch logs agent
Implementing the Serverless Audit Logging Pattern6:46
How can I monitor my AWS account activity?
Enable AWS CloudTrail
Push logs to CloudWatch logs, optionally have a lambda scan them for suspicious activity
Create Alarms that trigger on suspicious activates
Implementing the Serverless Distributed Tracing Pattern6:03
How can I configure Lambda, DynamoDB and other microservices to send traces to X-Ray?
Enable built-in Lambda X-Ray integration with the correct policy
For Lambda and DynamoDB in Python use aws-xray-sdk via xray_recorder begin and end, or decorators
For non-lambda services use aws-xray-daemon
Creating a Serverless Discovery Service and Catalogue6:25
How can I architect a serverless discovery and catalogue service?
For batch discovery use a lambda function that lists all resources, and persists results to DynamoDB
For near-real-time use AWS CloudTrail that sends logs to CloudWatch logs that a lambda scans, and persists results to DynamoDB
Expose the DynamoDB catalogue using API gateway via a Lambda proxy
Continuous Integration and Continuous Delivery16:00
What are the focus and differences of Continuous Integration, and Continuous Delivery, and Continuous Deployment?
Use continuous Integration to focus on automating build and testing to detect issues early
Use Continuous Delivery to focus on automated release process with a human approval step for the production release
Use Continuous Deployment to focus on a fully automated release process without a human approval step for the production release
Serverless Continuous Integration and Continuous Delivery Setup6:09
What AWS managed services are used in a serverless CI/CD pipeline and what are they for?
Use IAM roles and polices for security and access
Use AWS CodeCommit for code version control. Use AWS CodeBuild to manage build service
Use AWS CodePipeline for continuous delivery, and as a service that helps you build a CI/CD pipeline
Using CodeCommit for the Serverless Data API Code6:55
How can you access AWS CodeCommit?
With Git credentials use HTTPS or SSH Keys
Generate them in IAM
Attach the CodeCommit access policy to the IAM User
Using CodeBuild to Build-Test the Serverless Data API Stack10:20
How do you setup a CodeBuild project?
Use source code from CodeCommit or GitHub
Use an IAM role for CodeBuild to access the AWS resources or code
Generate a personal access token to access GitHub over HTTPS
Using CodePipeline as CI/CD for the Serverless Data API Stack12:46
How can you create a CodePipeline?
Use An IAM role for CodePipeline to access the AWS resources or code
Setup CodePipeline stages
Configure each CodePipeline stage with one or more actions such as source, build, deploy, and approve
Using Other CI/CD Solutions with the Serverless Data API Stack13:55
How can you setup other CI/CD tools for serverless?
Use their YAML files
Use a Makefile
Use CloudFormation with SAM to build and deploy you serverless stack
When to Use and Not Use Serverless Computing?18:33
When is it best to use serverless computing versus containers?
Look at your non-functional requirements
Use containers for very low latency < 50ms, large number of concurrent requests > 3000, large deployments packages and fixed costs
Use serverless when you require latency > 50ms, focus on business logic code, PAYG costs, and you are already on AWS
Estimating Serverless Stack Costs10:37
How can we estimate the serverless costs?
See the number of concurrent and average length of the requests
See data sizes and read/write capacities
Monitor costs in billing dashboard
Database and Event Streaming Scalability7:33
How do you scale database and event streaming resources?
Scale DynamoDB using GSI, creating a batch API and using DAX
Scale Aurora using read-replicas, DB optimization. Runload testing with production loads and monitor performance
Scale Kinesis Streams look at the number of consumers required, and load test by replying full production volumes
Web Scale Best Practices14:25
How do I ensure Lambda functions work at web scale?
Set lambda concurrency limits
Use lambda pre-warming to reduce their launch time
Use lambda code optimizations such as reducing package size, logging and declare objects outside lambda_handler()
Conclusion11:37
This video concludes the entire course.
Test Your Knowledge

Requirements

Basic knowledge of programming and AWS is required. Familiarity with DevOps will be beneficial, but not necessary.

Description

Microservices are a popular new approach to building maintainable, scalable, cloud-based applications. AWS is the perfect platform for hosting Microservices. Recently, there has been a growing interest in serverless computing due to the increase in developer productivity, built in auto-scaling abilities, and reduced operational costs.In combining both microservices and serverless computing, organizations will benefit from having the servers and capacity planning managed by the cloud provider, making them much easier to deploy and run at scale.

This comprehensive 2-in-1 course is a step-by-step tutorial which is a perfect course to implementing microservices using serverless computing on AWS. Build highly available microservices to power applications of any size and scale. Get to grips with microservices and overcome the limitations and challenges experienced in traditional monolithic deployments. Design a highly available and cost-efficient microservices application using AWS. Create a system where the infrastructure, scalability, and security are managed by AWS. Finally, reduce your support, maintenance, and infrastructure costs.

This training program includes 2 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Building a Scalable Serverless Microservice REST Data API, covers practical solutions to building Serverless applications. In this course we show you how to build an end-to-end serverless application for your organization. We have selected a data API use case that could reduce costs and give you more flexibility in how you and your clients consume or present your application, metrics and insight data. We make use of the latest serverless deployment and build framework, share our experience on testing, and provide best practices for running a serverless stack in a production environment.

The second course, Implementing Serverless Microservices Architecture Patterns, covers implementing Microservices using Serverless Computing on AWS. In this course, We will show you how Serverless computing can be used to implement the majority of the Microservice architecture patterns and when put in a continuous integration & continuous delivery pipeline; can dramatically increase the delivery speed, productivity and flexibility of the development team in your organization, while reducing the overall running, operational and maintenance costs. By the end of the course, you’ll be able to build, test, deploy, scale and monitor your microservices with ease using Serverless computing in a continuous delivery pipeline.

By the end of this course, you will be able to build, test, deploy, scale, and monitor your APIs and microservices with ease using serverless computing in a continuous delivery pipeline.

Meet Your Expert(s):

We have the best work of the following esteemed author(s) to ensure that your learning journey is smooth:

Richard T. Freeman, PhD currently works for JustGiving, a tech-for-good social platform for online giving that’s helped 25 million users in 164 countries raise $5 billion for good causes. He is also offering independent and short-term freelance cloud architecture & machine learning consultancy services. Richard is a hands-on certified AWS Solutions Architect, Data & Machine Learning Engineer with proven success in delivering cloud-based big data analytics, data science, high-volume, and scalable solutions. At Capgemini, he worked on large and complex projects for Fortune Global 500 companies and has experience in extremely diverse, challenging and multi-cultural business environments. Richard has a solid background in computer science and holds a Master of Engineering (MEng) in computer systems engineering and a Doctorate (Ph.D.) in machine learning, artificial intelligence and natural language processing. See his website for his latest blog posts and speaking engagements. He has worked in nonprofit, insurance, retail banking, recruitment, financial services, financial regulators, central government and e-commerce sectors, where he:

-Provided the delivery, architecture and technical consulting on client site for complex event processing, business intelligence, enterprise content management, and business process management solutions.

-Delivered in-house production cloud-based big data solutions for large-scale graph, machine learning, natural language processing, serverless, cloud data warehousing, ETL data pipeline, recommendation engines, and real-time streaming analytics systems.

-Worked closely with IBM and AWS and presented at industry events and summits, published research articles in numerous journals, presented at conferences and acted as a peer-reviewer.

-Has over four years of production experience with Serverless computing on AWS.

Who this course is for:

This course is for developers, architects, and DevOps administrators who would like to build and deploy serverless APIs and microservices with AWS for their organizations.

Serverless Microservices on AWS in 10 Hours

What you'll learn

Explore related topics

Course content

Building a Scalable Serverless Microservice REST Data API23 lectures • 2hr 46min

Implementing Serverless Microservices Architecture Patterns42 lectures • 7hr 16min

Requirements

Description

Who this course is for: