Do you have the next best idea? How will you quickly migrate a legacy feature to new world for almost free? This talk will give you how to architect and implement your scenario for a cloud-oriented solution. We will share the best practices for storing your state in database; ways to decouple by events and suggested patterns for serverless. You will be equipped with taking advantage of low-cost serverless computing in a secure way and how to minimize operational costs. It will mostly focus AWS offerings like Serverless Aurora, API Gateway and Lambda functions for solutions blueprint
10. @bsubra
WHY?
• Smallest Unit of Compute – Pure Code
• Super, Hyper-Scalable
• Rapid Iteration, CI, CD, Quickest Delivery
• Extreme multi-tenancy
• Very Polyglot friendly (Java, JS, C#, Python,
Powershell, F#, Typescript, PHP, Go and so on)
• Easier to Collaborate – Microservices, APIs
• Deploy Independently – Go live to production
in seconds
16. @bsubra
WHAT?
• Abstraction of backend infrastructure
Completely
• Execution environment for single purpose
functions
• Hosted in public cloud or on-premise
• Serverless functions have a runtime in a
stateless container
• Node.JS, JavaScript, C#, Python, Java
• Event-driven Startup Triggers / Instant Scale-
out or Scale-in
• Micro-billing instead of per-hour / per-month
billing
20. @bsubra
MICROSERVICES ARCHITECTURE
• Services can communicate via
• through synchronous API requests (for example API
Gateway)
• through asynchronous messaging between services (for
example SQS and SNS)
• through a state machine orchestrator
• State: Backend-as-a-Service (Baas): infrastructure
components managed by a Cloud Provider
• Google Cloud Firestore
• Azure Storage / AWS S3 / Google Cloud Storage
• CosmosDB / DynamoDB
• Azure Kubernetes Service (AKS)
• Google BigQuery
22. @bsubra
EVENT DRIVEN ARCHITECTURE (EDA)
• Design Pattern around the Production
and Reaction to Events
• Serverless Functions are triggered by
Events
• Examples of Events
• A File uploaded to an S3 bucket
• Inserts on a DynamoDB Table
• A Message published to an SNS topic –
PubSub
• A CloudWatch Alert
• A message is available to read from a
Kinesis stream
24. @bsubra
EXAMPLES OF SERVERLESS USE CASES
• Multimedia processing
• Database changes or Change Data Capture
• IoT sensor input messages
• Stream processing at scale
• Chat bots
• Batch jobs scheduled tasks
• HTTP REST APIs and web apps
• Mobile back ends
• Business logic
• Continuous integration pipeline
Source: CNCF Serverless Whitepaper
v1.0
25. @bsubra
TIPS AND TRICKS
• Limit your Function Size (JVM Startup time especially)
• Remember Execution is Async
• Do not assume function container reuse but take advantage of it
• Audit dependencies to keep bundle sizes small.
• CloudWatch's default log retention period is forever.
• Structure your logs to ease alert creation and debugging
• Understand AWS account limits
• Think twice before dynamically provisioning AWS resources.
• Price - Is Serverless really as cheap as everyone claims? (dev.to) Unless you are
operating at massive scale, serverless is not just cheap, it's a steal.
26. @bsubra
BEST PRACTICES
• Scrutinize and research before attaching new input/event sources
• Keep the functions’ permissions least privileged and maintain a least privileged build system
• Amount of code that can access sensitive data be reduced, exceptions are handled and input is
validated
• Avoid embedding secrets and access keys in code
• Do not store access keys or credentials in source code repositories
• Throttle and define quotas on the amount of requests that go through
• Keep data encrypted that is stored at rest
• Scrutinize and keep tab on third party API services for vulnerabilities
• Scan third party libraries for potential vulnerabilities and try to keep them up-to-date
• Carefully examine granting permissions that allow creation, modification or removal of the resources
28. @bsubra
SERVERLESS FAILURE STORIES
• Serverless out of control
• Mo’ developers, mo’ problems: How serverless has trouble with teams
• Beware “RunOnStartup” in Azure Functions – a serverless horror story
• Serverless: A lesson learned. The hard way.
• Serverless: 15% slower and 8x more expensive
29. @bsubra
DYNAMODB - BEST PRACTICES
• Where it could be Used?
• Wherever we see relationships…
• Document management
• Process control
• Social network
• Data trees
• IT monitoring
• Takeaways
• NoSQL does not mean non-relational
• The ERD still matters
• RDBMS is not deprecated by NoSQL
• Use NoSQL for OLTP or DSS at Scale.
• Use RDBMS for OLAP or OLTP when Scale is not important.
30. @bsubra
DYNAMODB ANTI-PATTERNS
• Prewritten application tied to a traditional relational database – If you are attempting to port an
existing application to the AWS cloud and need to continue using a relational database, you may elect
to use either Amazon RDS (Amazon Aurora, MySQL, PostgreSQL, Oracle, or SQL Server), or one of the
many pre-configured Amazon EC2 database AMIs. You can also install your choice of database
software on an EC2 instance that you manage.
• Joins or complex transactions – While many solutions are able to leverage DynamoDB to support
their users, it’s possible that your application may require joins, complex transactions, and other
relational infrastructure provided by traditional database platforms. If this is the case, you may want to
explore Amazon Redshift, Amazon RDS, or Amazon EC2 with a self-managed database.
• Binary large objects (BLOB) data – If you plan on storing large (greater than 400 KB) BLOB data,
such as digital video, images, or music, you’ll want to consider Amazon S3. However, DynamoDB still
has a role to play in this scenario, for keeping track of metadata (e.g., item name, size, date created,
owner, location, etc.) about your binary objects.
• Large data with low I/O rate –DynamoDB uses SSD drives and is optimized for workloads with a
high I/O rate per GB stored. If you plan to store very large amounts of data that are infrequently
accessed, other storage options may be a better choice, such as Amazon S3.
31. @bsubra
LAMBDA - BEST PRACTICES
• Minimize package size to necessities
• Separate the Lambda handler from core logic
• Read only what you need
• Properly Indexed Databases
• Query Filters in Aurora
• Use S3 Select
• Dynamic Logic via Configuration
• Per Function - Use Environment Variables to modify operational behavior
• Cross Function – Amazon Parameter Store / Secrets Manager
• Self-contain dependencies in your function package
• Leverage “Max Memory Used” to right-size your functions
• Use Functions to TRANSORM (not for TRANSPORT)
• Delete large unused functions (used to be 75GB limit)
32. @bsubra
LAMBDA – ANTI-PATTERNS
• Long-running applications – Each Lambda function must complete within 300
seconds. For long-running applications that may require jobs to run longer than five
minutes, Amazon EC2 is recommended or you create a chain of Lambda functions
where function 1 calls function 2, which calls function 3, and so on until the process is
completed.
• Dynamic websites – While it is possible to run a static website with Lambda, running
a highly dynamic and large volume website can be performance prohibitive. Using
Amazon EC2 and Amazon CloudFront would be a recommended use case.
• Stateful applications –Lambda code must be written in a “stateless” style; that is, it
should assume there is no affinity to the underlying compute infrastructure. Local file
system access, child processes, and similar artifacts may not extend beyond the
lifetime of the request, and any persistent state should be stored in Amazon S3,
DynamoDB, or another Internet-available storage service.
40. @bsubra
Features AWS Lambda Azure Functions Google Cloud Functions
Language
Support Node.js, Java, C#, Python Node.js, C#, F#, Python, PHP Node.js
Security
AWS IAM, VPC
OAuth providers such as Azure Active Directory, Facebook, Google,
Twitter, and Microsoft Account Cloud IAM
Monitoring Cloudwatch Application Insights Stackdriver Monitoring
Logging Cloudwatch Application Insights Analytics Stackdriver Logging
Auditing CloudTrail Azure Audit Logs Cloud Audit Logging
Alerts Cloudwatch Alarms Application Insights, Log Analytics, and Azure Monitor Stackdriver Monitoring
Tooling
Support CodePipeline, Code Build Azure Portal, Azure Powershell, Azure CLI, Azure SDK gcloud CLI for functions
Debugging
Support AWS X-Ray
Azure CLI - local debugging,
Azure App Service - remote debugging Stackdriver Debugger
Pricing
it depends
Execution Time: $0.000016/GBs, 400,000 GBs/month are free
Total Executions: $0.20/million executions, with 1 million
executions/month free
Invocations: $0.40/million invocations with 2 million invocations free
Compute Time: $0.0000025/GBsec with 400,00 GB-sec/month free &
$0.0000100/GHzsec with 200,000 GHz-sec/month free
Limits
Memory allocation range: Min. 128 MB / Max. 1536 MB (with 64 MB
increments)
Ephemeral disk capacity ("/tmp" space): 512 MB
Number of file descriptors: 1,024
Number of processes and threads (combined total): 1,024
Maximum execution duration per request: 300 seconds
Invoke request body payload size (RequestResponse): 6 MB
Invoke request body payload size (Event): 128 K
Invoke response body payload size (RequestResponse): 6 MB
Allow only 10 concurrent executions per function
No limitations on max. execution time limit
Resource, Time and Rate Limits are defined under Google Cloud Functions
Quota limits
41. @bsubra
DISADVANTAGES
• Portability
• Automation / DevOps
• Cross-Cloud Communication
• The Cold Start Problem
• Applications that haven't been used recently
take longer to startup and to handle the first
request.
• Because serverless happens on use, there
aren’t dedicated instances ready to handle
requests
• Solution: Run a function in a dedicated
container/VM, not serverless
46. @bsubra
CONSIDERATIONS FOR THE ENTERPRISE
• Cloud Silos
• Enterprise Eventing
• Serverless skills gap
• Monitoring vs. Observability
• Stateful vs. Stateless
• Forecasting costs
• Where serverless falls short
Source: The New Stack Serverless Survey 2018
Q: What are the top three areas in which serverless falls short of expectations?
47. @bsubra
WORKS CITED
• Serverless Architectures - Martin Fowler
• Serverless on Google Cloud Platform: an
Introduction with Serverless Store Demo
• Introduction to Serverless: RISE Conference 2018 -
Hong Kong Developer Workshop: Introduction to
Serverless - Shaun Ray
• Serverless is a Doctrine, not a Technology - Paul
Johnston – Medium
• The Serverless Sea Change
• How AWS built a production service using
serverless technologies | AWS Open Source Blog
• Serverless Architectural Patterns and Best Practices
| AWS Architecture Blog
• Contemporary Views on Serverless and
Implications - Subbu’s Blog
@bsubra
48. @bsubra
SERVERLESS ON GOOGLE CLOUD PLATFORM
• App Engine | Google Cloud
• 1. Auth, Storage, Event Streaming, and Third-Party APIs (Firebase Authentication,
Cloud Storage, Cloud Firestore, Cloud Pub/Sub and Third-Party APIs)
• 11. Machine Learning, AI, Data Analytics, and Data Visualization (Cloud Vision API,
Cloud AutoML, DialogFlow +Google Assistant integration, BigQuery and Data Studio)
• 111. Serverless Computing, Management Tools, and Cron Jobs (App Engine, Cloud
Functions, Cloud Scheduler, Stackdriver Logging, Stackdriver Monitoring, and
Stackdriver Tracing)
• 1111. Hacking Google Cloud Run
49. @bsubra
CALL TO ACTION
1. Write an AWS Lambda from Template
• How do I get started with creating serverless applications?
2. Make your monolithic app use Step Functions
3. Try how Azure Kubernetes Service (AKS) can deploy your legacy apps
4. Make your next project be event driven with Azure Event Grid, or GCP Cloud Pub/Sub
• Building a Reliable Serverless Application in a Weekend
5. Become familiar with application observability with comprehensive logging, metrics, and
tracing
6. Follow folks pushing Serverless in twitter
7. Read a book
• Serverless apps: Architecture, patterns, and Azure implementation | Microsoft Docs
8. Watch Videos like
• AWS re:Invent: Accelerate Innovation & Maximize Business Value w/ Serverless Apps (SRV212-R1)
• Keynote: Serverless, Not So FaaS - Kelsey Hightower, Kubernetes Community Member, Google
APIs, Serverless Functions, Microservices - How to get your product quickly to market?
Do you have the next best idea? How will you quickly migrate a legacy feature to new world for almost free? This talk will give you how to architect and implement your scenario for a cloud-oriented solution. We will share the best practices for storing your state in database; ways to decouple by events and suggested patterns for serverless. You will be equipped with taking advantage of low-cost serverless computing in a secure way and how to minimize operational costs. It will mostly focus AWS offerings like Serverless Aurora, API Gateway and Lambda functions for solutions blueprint.
Balaji is a Boston-based developer, writer, speaker and debugger. He has expertise in infrastructure, internet technologies, and systems integration obtained through 20 plus years of working as a manager, architect and developer on projects for mission critical back end systems that have included various cloud platforms such as OpenStack, AWS and Azure. As a degreed Industrial engineer, he also has experience in distributive controls systems as a controls engineer at Honeywell. He has also worked extensively with global hedge fund industry providing SaaS solutions on the public cloud.
An elderly couple had dinner at another couple's house, and after eating, the wives left the table and went into the kitchen. The two gentlemen were talking, and one said, 'Last night we went out to a new restaurant and it was really great. . . I would recommend it very highly.' The other man said, 'What is the name of the restaurant?' The first man thought and thought and finally said, 'What is the name of that flower you give to someone you love? You know... The one that's red and has thorns.' 'Do you mean a rose?' 'Yes, that's the one,' replied the man. He then turned towards the kitchen and yelled, 'Rose, what's the name of that restaurant we went to last night?'
Development, debugging, deployment, delivery, and decommissioning of application services are the major portion of any application lifecycle management (ALM) process.
This serverless deployment pattern recommends a kind of deployment infrastructure that hides the concept of servers (whether physical or virtual). The infrastructure takes the application service's code and runs it. The user has to pay for each of his requests based on the resources consumed. The performance, scalability, and availability requirements are being automatically met. Almost all the established cloud service providers are providing this new deployment pattern. This is a new cloud service ensuring every function is being delivered as a service.
Serverless Can Help You To Focus - By Simona Cotin: Time is crucial in startups. We are experiencing a constant race against time. Your market might be time sensitive, and you need to grow fast. Most startups fail because they run out of cash and time. Serverless helps you spend time only on things that matter instead of stuff that seems shiny but isn’t essential.
Two Uni Students From Queensland Built a Better Census Site in One Weekend - VICE: Their website is faster, cheaper, and more secure. And they didn't even fill out the Census this year.
It cost the Australian Bureau of Statistics (ABS) many years and $9 million to build its somewhat inadequate Census website, which was taken down by a DDoS attack after being online for mere hours. Over the weekend, two uni students from Queensland were able to build a better Census site in two days for only $500.
The two young computer geniuses behind the aptly-named Make Census Great Again website are students Austin Wilshire (18) and Bernd Hartzer (24). Both hail from the Queensland University of Technology. Their system can handle nearly 40 times as many census submissions per second as the ABS one can, and is specifically designed to prevent the DDoS attack that forced the Census offline on August 9.
Intro to Serverless: A little bit of history, evolution, misconceptions around serverless
Benefits: Get into why serverless, its benefits and characteristics
Adoption: Insight into the adoption by enterprises and the tech community in general
Architecture: Discussions around serverless architecture, FaaS, evolving patterns and solutions
Security: Auth. services, access controls, surface areas for attack, data isolation...
Development, Deployment & Testing: Rethinking around developing, deploying and testing serverless
applications and services
Toolsets: Evolving toolsets, frameworks and methodologies
Changing DevOps: A look into the changing roles of DevOps teams and the Mindshift
Challenges: Concerns around debugging, logging, and monitoring, of serverless applications
Providers: A comparative look at the serverless providers out there
Case Studies: Examples of real-life implementations of serverless technologies
No server management
Scales automatically
Pay only while your code runs
Runs code in response to events
Open and familiar
Connects and extends cloud serviceshttps://twitter.com/PaulDJohnston/status/1186908841100886017
AMG Earnings Q3 19: The Future of the Tech Industry – Bernard Golden
Last week all three of the most important cloud providers (I refer to them collectively as AMG — Amazon, Microsoft, and Google) announced their financial results. All continue to see impressive growth and, as a group, have achieved very significant results. The chart below indicates that the three are generated something like $16B or $17B for the quarter, although it’s impossible to be precise because Microsoft and Google do not break out their pure cloud computing revenues.
The Leading Open Source Serverless Solutions for Kubernetes: The universe of serverless-wielding software architects and Kubernetes cluster operators has started to collide and, yet again, Google is in the driver's seat. In this article we'll wander down the CNCF's Serverless Landscape in chronological order, quickly discovering that Knative is the sweet mamba jamba of open source lambda competitors.
6 Strategies for Migrating Applications to the Cloud
Rehosting — Otherwise known as “lift-and-shift.”
Replatforming — I sometimes call this “lift-tinker-and-shift.”
Repurchasing — Moving to a different product.
Refactoring / Re-architecting — Re-imagining how the application is architected and developed, typically using cloud-native features.
Retire — Get rid of.
Retain — Usually this means “revisit” or do nothing (for now).
Serverless computing promises a pay-as-you-go future with (almost) no server management at all. Serverless platforms take the code from developers and perform all the deployment tasks (networking, dependencies, maintenance, etc.) automatically behind the scenes
Serverless application
Event Source
Function
StoreCloud Functions - Event-driven Serverless Computing | Cloud Functions | Google Cloud
1. Zero Administration: This is the most exciting thing about serverless. Whereas previous abstractions like VMs and containers still shared a lot of the same configuration and administration properties of servers, serverless is a completely different experience. When you're ready to deploy code, you don't have to provision anything beforehand, or manage anything afterward. There is no concept of a fleet, an instance, or even an operating system. Everything runs in the cloud and the provider manages scaling for you.
2. Pay-per-execution: This is what typically incentivizes developers to try serverless for the first time. It’s alluring to have complete resource utilization without paying a cent for idle time. This tenet alone results in over 90% cost-savings over a cloud VM and immeasurable developer satisfaction in knowing that you never have to pay for resources that you don’t use.
3. Function as unit of deployment: Serverless architectures are composed of very small, independent bits of code (functions) that are loosely coupled and collaborative—also known as a microservice architecture. The main advantage? Pieces of the system are contained. They can be developed and deployed independently. The result is fewer blockers and far greater developer autonomy and productivity.
4. Event-Driven: This aspect of serverless is the most under-the-radar right now, but is shaping up to be the most important in the long-term. Serverless functions are stateless, and essentially dormant, until they have an event to react to. The event is what brings them to life and provides them with the data/context to do their job. Event-driven architectures are nothing new, but the rise of serverless compute has renewed interest in them because serverless architectures are by definition event-driven.
https://twitter.com/ben11kehoe/status/1097804380777205760
Which serverless compute platform is right for you?
https://cloud.google.com/serverless-options/
AWS Step Functions enables us to construct a state machine graph with custom logic, where each processing node can be either AWS Lambda, AWS Batch or AWS Fargate. The Step Function service tracks the completion of the task as well as if an exception occurred. It enables us to branch out logic in case of error (with the ability to customize the handling of an error), execute jobs in parallel and implement retry logic.
“clean architecture”, “hexagonal architecture” (ports and adapters), and “onion architecture”. Some argue it’s all the same.
Serverless Event Sourcing in AWS (Lambda, DynamoDB, SQS): In this post, I have presented the project structured using Event Sourcing and CQRS patterns, written in TypeScript. The project I was building was a “Twitter-like” service
Source: Ajay Nair, Principal Product Manager (AWS Lambda) at Amazon Web Services (AWS)
Event-driven architecture (EDA) is conceptually different than the client/server architecture most commonly used todayAll logic in an event-driven architecture is embodied in functions. Events trigger these functions and then the functions, in turn, trigger something downstream, which themselves may be functions, according to Ajay Nair, principal product manager for AWS Lambda at Amazon Web Services
the infrastructure provisioning, setting up and administering time, and treasure and talent get reduced significantly.
Software engineers can coolly focus on their core strengths without any botheration of the readying infrastructure to run their applications.
Cost
Elasticity versus scalability
Productivity
https://twitter.com/ShortJared/status/1100887501047132160
The job of a person in a business is not to provide technology, but to provide business value.
Follow AWS Best Practices. The Lambda and Using Lambda with SQS Best Practices helps avoid Lambda throttles, understand SQS message batches (they succeed or fail together) and configure redrive policies high enough to prevent prematurely sending messages to dead-letter queues.
A Common response to a recurring problem that is usually ineffective and risks being highly counterproductive
https://github.com/cristim/serverless-failure-stories
https://twitter.com/ajaynairthinks/status/1122197970743468033
Serverless and Microservices: a match made in heaven?: When the first tutorials started to come out using AWS Lambda and API Gateway, back in 2015, it was unsurprising to find that they focused largely on replicating the microservice. However, it…
Tenets of NoSQL Data Modeling
Understand the use case
Nature of the application
OLTP / OLAP / DSS
Define the Entity-Relationship Model
Identify Data Life Cycle
TTL, Backup/Archival, etc
Identify the access patterns
Identify data sources
Define query aggregations
Document all workflows
Read/Write workloads
Query dimensions and aggregations
Data-modeling
Avoid relational design patterns, use one table
1 application service = 1 table
Reduce round trips
Simplify access patterns
Identify Primary Keys
How will items be inserted and read?
Overload items into partitions
Define indexes for secondary access patterns
Review -> Repeat -> Review
Amazon DynamoDB helps you build serverless applications by providing a managed NoSQL database for persistent storage.
Combined with DynamoDB Streams you can respond in near real-time to changes in your DynamoDB table by invoking Lambda functions.
DynamoDB Accelerator (DAX) adds a highly available in-memory cache for DynamoDB that delivers up to 10x performance improvement from milliseconds to microseconds.
Exposed AWS Lambda Functions: Identify any publicly accessible AWS Lambda functions and update their access policy in order to protect against unauthorized users that are sending requests to invoke these functions
Allowing anonymous users to invoke your Amazon Lambda functions is considered bad practice and can lead to data exposure, data loss and unexpected charges on your AWS bill. To prevent any unauthorized invocation requests to your Lambda functions, restrict access only to trusted entities
Lambda Functions with Admin Privileges
AWS Lambda Unknown Cross Account Access
Lambda Runtime Environment Version
Using An IAM Role For More Than One Lambda Function
Tracing Enabled
Orchestrate your application with state machines, not functions: Chaining Lambda executions within the code to orchestrate the workflow of your application results in a monolithic and tightly coupled application. Instead, use a state machine to orchestrate transactions and communication flows.
AWS Serverless Application Model (AWS SAM) is an extension of AWS CloudFormation that is used to package, test, and deploy serverless applications. SAM Local can also enable faster debugging cycles when developing Lambda functions locally.
AWS Step Functions orchestrates serverless workflows including coordination, state, and function chaining as well as combining long-running executions not supported within Lambda execution limits by breaking into multiple steps or by calling workers running on Amazon Elastic Compute Cloud (Amazon EC2) instances or on-premises: Applying the Saga pattern with AWS Lambda and Step Functions | theburningmonk.comWith Amazon API Gateway, you can run a fully managed REST API that integrates with Lambda to execute your business logic and includes traffic management, authorization and access control, monitoring, and API versioning: Error Handling Patterns in Amazon API Gateway and AWS Lambda | AWS Compute BlogAccessing Amazon CloudWatch Logs for AWS Lambda - AWS LambdaA Simple Serverless Test Harness using AWS Lambda | AWS Compute BlogAWS Lambda Function Versioning and Aliases - AWS LambdaEnvironment Variables - AWS LambdaAWS Lambda and AWS X-Ray - AWS X-RayDead Letter Queues (DLQ) - AWS LambdaUnderstanding Container Reuse in AWS Lambda | AWS Compute Blog
Serverless web application - Azure Reference Architectures | Microsoft Docs: Recommended architecture for a serverless web application and web API.
Azure Serverless | Microsoft Azure
1 User accesses the web app in browser and signs in.
2 Browser pulls static resources such as images from Azure Content Delivery Network.
3 User searches for products and queries SQL database.
4 Web site pulls product catalog from database.
5 Web app pulls product images from Blob Storage.
6 Page output is cached in Azure Cache for Redis for better performance.
7 User submits order and order is placed in the queue.
8 Azure Functions processes order payment.
9 Azure Functions makes payment to third party and records payment in SQL database.
AWS - Multiple points to optimize - Invocations, Functions, Interactions
AWS Batch and AWS Fargate: why they are beneficial and what their differences are.
AWS Step Functions: how it is different from other ways of connecting services and what the advantages are.
What are some specific cases where hybrid infrastructure could be beneficial
Build a real-life serverless app with AWS Amplify
last year’s Re:Invent deep-dive video on DynamoDB
open source project designed to help customers learn from Amazon’s approach to building serverless applications. The project captures key architectural components, code structure, deployment techniques, testing approaches, and operational practices of the AWS Serverless Application Repository, a production-grade AWS service written mainly in Java and built using serverless technologies.
available in the project wiki.
Further Discussions for some tips and notes about Serverless Store.part of the Serverless on Google Cloud Platform: an Introduction with Serverless Store Demo How-to Guide. It discusses the authentication, storage, event streaming solutions, and third-party APIs Serverless Store uses.
It is only suitable for deploying stateless applications that run quickly and respond to requests.
Running long-running stateful applications such as a database or message broker in the serverless model is not possible.
If an application takes a long time to start, then the application is not a good fit for serverless deployment.
Similarly, legacy monolithic and massive applications are not suitable for serverless computing.
Serverless deployment is typically reactive, not proactive, and hence the issue of high latency can arise
https://twitter.com/jessfraz/status/942031487809085440
On the face of it, it would appear that choosing the lowest memory allocation for compute would be the cheapest. But that’s not always the case. Execution time may lengthen with smaller memory size allocations, thus raising the overall cost,
the company also used Amazon’s CloudWatch tools, which turned out to be surprisingly costly.
But perhaps the biggest hidden cost comes from API requests.
when a bug in its CloudWatch function prevented the service from scaling well. They discovered that 5,000 functions were repeatedly getting timeouts that amounted to a cost of $12,000 per month — a fortune for a small startup.
Cloud providers do, thankfully, offer the ability to set rate limits and spending thresholds on service accounts and will issue automatic billing alerts if you reach your limits. But closely monitoring risks associated with spiking and ensuring that estimated costs will not jump from poor performance of serverless workflows and systems will be a focus in the coming year
LambdaGuard - tool which allows you to visualize and audit the security of your serverless assets, an open-source AWS Lambda Serverless Security Scanner. https://darknet.org.uk/2019/10/lambdaguard-aws-lambda-serverless-security-scanner/… via @THEdarknet
statistical analysis
AWS service dependencies
configuration checks
AWS Lambda automatically monitors Lambda functions on your behalf. Through Amazon CloudWatch, it reports metrics such as the number of requests, the execution duration per request, and the number of requests resulting in an error. These metrics are exposed at the function level, which you can then leverage to set CloudWatch alarms.
Using Amazon CloudTrail, you can implement governance, compliance, operational auditing, and risk auditing of your entire AWS account, including Lambda. CloudTrail enables you to log, continuously monitor, and retain account activity related to actions across your AWS infrastructure, providing a complete event history of actions taken through the AWS Management Console, AWS SDKs, command line tools, and other AWS services. Using CloudTrail, you can optionally encrypt the log files using Amazon Key Management Service (KMS) and also leverage the CloudTrail log file integrity validation for positive assertion.
Using AWS X-Ray, you can analyze and debug production and distributed Lambda-based applications, which enables you to understand the performance of your application and its underlying services, so you can eventually identify and troubleshoot the root cause of performance issues and errors. X-Ray’s end-to-end view of requests as they travel through your application shows a map of the application’s underlying components, so you can analyze applications during development and in production.
With AWS Config, you can track configuration changes to the Lambda functions (including deleted functions), runtime environments, tags, handler name, code size, memory allocation, timeout settings, and concurrency settings, along with Lambda IAM execution role, subnet, and security group associations. This gives you a holistic view of the Lambda function’s lifecycle and enables you to surface that data for potential audit and compliance requirements
Whole-Event Serverless Observability - IOpipe Blog
The Serverless Vector Map Stack Lives! - Alexander Rolek - Medium: TL;DR: With the release of AWS Aurora Serverless Postgres (with PostGIS support), building an entirely serverless map stack is now possible, including the database.
How to FaaS like a pro: 12 less common ways to invoke your serverless functions on AWS
Watch Google Global Digital Conference 2019.Watch more #io19 here:
GCP at Google I/O 2019 Playlist → https://goo.gle/2ZPLejw
Google I/O 2019 All Sessions Playlist → https://goo.gle/io19allsessions
Learn more on the I/O Website → https://google.com/io
Google Cloud Platform Channel → https://goo.gle/GCP
Get started at → https://cloud.google.com/gcp
When you’re building serverless applications on AWS, you can use AWS CloudFormation directly, or choose the AWS Serverless Application Model, also known as AWS SAM.
Introduction to Serverless
Building large scale applications with AWS Lambda
Building Enterprise-Grade Serverless Applications
Best Practices for Optimizing your Data Lake with AWS Serverless
Real-Time Streaming Analytics and Machine Learning in Serverless Era
Serverless Development, CI/CD
Serverless database for your Serverless App
Serverless intelligence - the fastest path to smart applications