Last updated 8/2018MP4 | Video: h264, 1280×720 | Audio: AAC, 44.1 KHzLanguage: English | Size: 4.21 GB | Duration: 11h 37m

The perfect course to implementing cost-effective, and scalable Microservices using Serverless Computing on AWS

What you’ll learn

Improve the reusability, composability, and maintainability of code.

Create a highly available serverlessmicroservice data API.

Build, deploy and run your serverless configuration and code.

Speed up delivery, flexibility and to market using serverlessmicroservices.

Add your microservices to a continuous integration & continuous delivery pipeline.

Estimate, and reduce maintenance and running costs.

Implement over 15 microservices architecture patterns without needing containers or EC2 instances.

Scale up without significant changes to tooling, architecture, or development practices.

Reduce the risk and cost of operating a cloud platform.

Requirements

Prior experience to traditional application development is assumed.

Basic understanding of microservices and serverless architecture will be useful.

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. Building a microservices platform using virtual machines or containers, involves a lot of initial and ongoing effort. There is a cost associated with having idle services running, maintenance of the boxes and a configuration complexity involved in scaling up and down. 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 3-in-1 course is a step-by-step tutorial which is a perfect course to implementing Microservices using Serverless Computing on AWS. Build highly availablroservices 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.Contents and OverviewThis training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.The first course, Building Microservices on AWS, covers building highly available Microservices to power applications of any size and scale. This course shows you how to build Microservices-based applications on AWS. Overcome the limitations and challenges you experience in traditional monolith deployments. By the end of the course, you’ll have learned to apply AWS tools to create and deploy Microservices-based applications. You’ll be able to make your applications cost-effective, easier to scale, and faster to develop.The second course, Building a Scalable ServerlessMicroservice 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 third course, Implementing ServerlessMicroservices 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 the course, you’ll create a secure, scalable, and Serverless data API to build highly available Microservices to power applications of any size and scale.About the Authors● Alan Rodrigues has been working on software components such as Docker containers and Kubernetes for the last 2 years. He has extensive experience working on the AWS Platform, currently being certified as an AWS Solution Architect Associate, a SysOps Administrator, and a Developer Associate. He has seen that organizations are moving towards using containers as part of their Microservices architecture. And there is a strong need to have a container orchestration tool in place. Kubernetes is by far the most popular container orchestration on the market.● 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 Eeer with proven success in delivering cloud-based big data analytics, data science, high-volume, and scalable solutions. At Capgi, he worked on large and complex projects for Fortune Global 500 companies and has experience in extremely diverse, challeg and multi-cultural business environments. Richard has a solid background in computer science and holds a Master of Eeering (MEng) in computer systems eeering 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 ees, and real- 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.

Overview

Section 1: Building Microservices on AWS

Lecture 1 The Course Overview

Lecture 2 The Concepts of Microservices

Lecture 3 Benefits of Microservices

Lecture 4 Key Design Elements for Microservices

Lecture 5 Understanding AWS EC2 and ELB

Lecture 6 Decentralizing AWS Data Options

Lecture 7 AWS Elastic Beanstalk

Lecture 8 Working with AWS Lambda

Lecture 9 AWS API Gateway

Lecture 10 AWS Route 53

Lecture 11 Monitoring Microservices

Lecture 12 Exploring Blue Green Deployments

Lecture 13 Using Elastic Load Balancer for Blue Green Deployments

Lecture 14 Using Elastic Beanstalk for Blue Green Deployments

Lecture 15 Getting Started with Continuous Integration

Lecture 16 Using AWS CodeCommit

Lecture 17 Implementing AWS CodeBuild

Lecture 18 Using AWS CodePipeline

Lecture 19 The Complete Continuous Integration Pipeline

Lecture 20 Working with Containers

Lecture 21 Using Orchestration

Lecture 22 Exploring Kubernetes

Lecture 23 Using AWS Elastic Container Service

Section 2: Building a Scalable Serverless Microservice REST Data API

Lecture 24 The Course Overview

Lecture 25 Monolithic and Microservice Architectures

Lecture 26 Virtual Machines, Containers, and Serverless Computing

Lecture 27 Serverless Computing in AWS

Lecture 28 Setting Up Your Serverless Environment in AWS

Lecture 29 Overview of Security in AWS

Lecture 30 Overview of AWS Identity and Access Management (IAM)

Lecture 31 Securing Your Serverless Microservice

Lecture 32 Building a Serverless Microservice Data API

Lecture 33 Setting Up a Lambda in the AWS Management Console

Lecture 34 Setting Up the API Gateway and Integrating It with a Lambda Proxy

Lecture 35 Creating and Writing to a NoSQL Database Called DynamoDB

Lecture 36 Creating a Lambda to Query DynamoDB

Lecture 37 Connecting API Gateway, Lambda, and DynamoDB

Lecture 38 Unit Testing Your Python Lambda Code

Lecture 39 Running and Debugging Your AWS Lambda Code Locally

Lecture 40 Integration Testing Using Real Test Data

Lecture 41 Performance and End-to-End Testing at Scale

Lecture 42 Overview of Serverless Stack Build and Deploy Options

Lecture 43 Creating an S3 Bucket, IAM Policies, and IAM Roles Resources

Lecture 44 Building and Deploying API Gateway, Lambda, and DynamoDB

Lecture 45 Building a Scalable Serverless Microservice Data API Conclusions

Lecture 46 Next Course

Section 3: Implementing Serverless Microservices Architecture Patterns

Lecture 47 The Course Overview

Lecture 48 Overview of Microservice Integration Patterns

Lecture 49 Communication Styles and Decomposition Microservice Patterns

Lecture 50 Serverless Computing to Implement Microservice Patterns

Lecture 51 Implementing Database Per Service and Shared Database Patterns

Lecture 52 Accessing DynamoDB from API Gateway Via a Lambda Function

Lecture 53 Accessing DynamoDB Directly from API Gateway

Lecture 54 Implementing the Transaction Log Tailing Pattern

Lecture 55 Implementing the Saga Pattern

Lecture 56 Securing Your DynamoDB Databases

Lecture 57 Relational Versus Non-Relational Databases

Lecture 58 Overview of Virtual Private Cloud

Lecture 59 Setting Up Virtual Private Cloud for Accessing RDS and Aurora

Lecture 60 Setting Up RDS and Accessing It from Your Local Network

Lecture 61 Accessing RDS from API Gateway Via a Lambda Function

Lecture 62 Accessing Aurora from API Gateway Via a Lambda Function

Lecture 63 Securing Your RDS and Aurora Databases

Lecture 64 API Gateway and API Composition Patterns

Lecture 65 Implementing the Serverless API Composition Patterns

Lecture 66 Event Sourcing and CQRS Patterns

Lecture 67 Architectures of the Serverless Event Sourcing Pattern

Lecture 68 Implementing the Serverless Event Sourcing Pattern

Lecture 69 Architectures of the Serverless CQRS Pattern

Lecture 70 Implementing the Serverless CQRS Pattern

Lecture 71 Securing Your Event Streams and Queries

Lecture 72 Monitoring and Observability Patterns

Lecture 73 Implementing Serverless Metrics and Health Check API Patterns

Lecture 74 Implementing the Serverless Centralized Logging Pattern

Lecture 75 Implementing the Serverless Audit Logging Pattern

Lecture 76 Implementing the Serverless Distributed Tracing Pattern

Lecture 77 Creating a Serverless Discovery Service and Catalogue

Lecture 78 Continuous Integration and Continuous Delivery

Lecture 79 Serverless Continuous Integration and Continuous Delivery Setup

Lecture 80 Using CodeCommit for the Serverless Data API Code

Lecture 81 Using CodeBuild to Build-Test the Serverless Data API Stack

Lecture 82 Using CodePipeline as D for the Serverless Data API Stack

Lecture 83 Using Other D Solutions with the Serverless Data API Stack

Lecture 84 When to Use and Not Use Serverless Computing?

Lecture 85 Estimating Serverless Stack Costs

Lecture 86 Database and Event Streaming Scalability

Lecture 87 Web Scale Best Practices

Lecture 88 Conclusion

Developers, software architects, and software eeers. Developers familiar with traditional application development but interested in using Microservices in a DevOps environment will also benefit. Microservices are appropriate to large-scale enterprise environments so this course should appeal to people interested in developing for those environments.,Developers who need practical solutions to common problems while building their serverless application. Programming knowledge is assumed.,Developers, architects, DevOps, administrators and operations who would like to deploy Serverless computing and microservices in their organization.