ac360

We've been building serverless application dev tools for ~4 years now. In the process, we've seen incredible efforts to emulate the cloud locally. The result is usually the same: it requires tons of effort, the work is often brittle, and it still is not identical to how your app will perform in the real cloud environment (e.g. you deploy and immediately run into an API limit error). Further, the reason developers mostly want local emulation is because deploying to the cloud is simpler too darn slow.

Given this experience, our hypothesis is if we can greatly increase the speed of deployment, developers will be less interested in local emulation.

With Serverless Components, we're now achieving incredible results. First deployment always takes a bit longer due to initial creation of resources, some of which are global (e.g. AWS IAM), but all Serverless Components are designed to deploy as fast as possible and we're aiming for ~5s max in deployment time as our key metric. We'll go into detail later about how we've been able to optimize this.

"Minutes" is a false statment for many runtimes and use-cases on AWS Lambda, including this one.

I've included some performance info in a comment below.

For clarity, the platform here is Amazon Web Services. We're just providing tooling to help you build and manage serverless architectures on AWS easily.

Yes, we're looking at providing a great solution for this.

In the interim, check out this Component (which is used by this project) which provides a simple webockets backend and can be used for that use-case - https://github.com/serverless-components/Socket

There are many case studies of AWS Lambda's scaling power and its constraints are well documented. The newcomer in the serverless architecture is AWS API Gateway Websockets, and I personally have not performed any tests using this service within a variety of use-cases at significant scale (it's still a new service).

When it comes to migration, it depends on your use-case. A few suggestions which may be helpful:

* Consider your data strategy (much lock-in happens at this level). Most serverless architectures leverage DynamoDB because its design pairs well with stateless compute like AWS Lambda. You can use DynamoDB within all types of architectures.

* Don't use AWS API Gateway specific URLs in your application. Use custom domains. This will enable you to easily swap out your websockets endpoint. Fortunately, there is only 1 endpoint in this architecture, so there is little surface area to refactor.

* Make sure you understand the cost of these serverless technologies at scale before building with them. But don't forget to factor in the reduced labor costs of using serverless technologies.

Good question. As always, it depends on the use-case. But to be helpful, we've added the relevant pricing pages here: https://github.com/serverless-components/RealtimeApp/blob/ma...

@scarface74 We have three projects. Here's how they may be helpful to you:

1) Serverless Framework

The Serverless Framework enables you to provision serverless applications in a Function + Events pattern. Using this, you can accomplish the patterns you're describing, and hundreds of thousands of people are doing this already with the Framework.

https://github.com/serverless/serverless

2) Serverless Framework Enterprise

SFE works with the Serverless Framework to give you more than development and deployment convenience. SFE focuses on other phases of the serverless application lifecycle, like monitoring, alerting, security, collaboration, secrets and much more. It's a powerful solution for teams and orgs investing more in serverless application development.

https://serverless.com/enterprise

3) Serverless Components

This is a new take on serverless application development. We've learned the serverless community and teams are looking for ways to deploy and share composable architectural pieces (features, use-cases), more than infra. So we're building a new type of provisioning system to enable this. The Realtime Application Component is an example of this.

https://github.com/serverless-components/RealtimeApp

Here is a real-world example built using this project. It's a full Chat Application:

https://github.com/serverless-components/RealtimeApp/tree/ma...

You can deploy this example. It contains a Create React App front-end and it uses DynamoDB on the back-end to keep track of who is connected to the Chat Application.

@scarface74 Let us know what you need. We have about a dozen more coming out within the next week.

Absolutely. This project is built on Serverless Components, which are composable architectural pieces based on serverless cloud infrastructure.

One of the child Components powering this project is the Socket Component, which allows anyone to provision a serverless websockets backend simply. You can use it here: https://github.com/serverless-components/Socket

Done! This project can be deployed with YAML or programmatically w/ Javascript.

Here is an example of a full Chat Application that demonstrates how you can provision and extend this Serverless Realtime Application Component programmatically, very much like a React Component.

https://github.com/serverless-components/ChatApp/blob/master...

In a websockets implementation w/ AWS Lambdas and AWS API Gateway maintaining connection state, your AWS Lambdas are invoked whenever someone 1) connects 2) disconnects 3) sends a message.

This project's pattern uses a single AWS Lambda function for all of those events, for the sake of simplicity as well as performance because by receiving more events, the function is kept warmer than average.

Further, when the user loads a page, if you establish the connection at that time, you warm up the function in the background by sending the connection event.

Here is full Chat Application example you can deploy to test performance: https://github.com/serverless-components/RealtimeApp/tree/ma...

When deployed to us-east-1 and using it in San Francisco, when the Chat App loads, it establishes the websockets connection immediately via React's componentWillMount(), which will warm the AWS Lambda Function. By the time I send the first chat message, the function is already warm, and it takes ~100ms on average to send and receive messages.

Serverless.com | Open-Source Developers • Dist-Sys. Engineers • Product Managers | Remote

Due to the fast pace of change, many organizations cannot keep up (let alone lead) by building & maintaining all of their IT.

This has given rise to the "serverless architecture", an application pattern that uses high-level managed services like AWS Lambda, AWS API Gateway, Auth0, Stripe, Twilio, Netlify, etc. to deliver applications quickly with remarkably low overhead.

Our company helps orgs build & operate serverless architectures. We started with the Serverless Framework (https://www.github.com/serverless/serverless). Now, we're currently expanding our line of products.

If developer tools, open-source & enabling all engineers to "build more & manage less" is of interest to you, please apply here: https://serverless.com/company/jobs

imo, the most interesting data point is how in demand serverless architectures are WITH these issues. Imagine how compelling serverless will be once these issues are solved.

Serverless Inc. | SF or REMOTE | Engineers - Full-Stack, Dist. Systems | Full-time | serverless.com

Be at the forefront of the cloud. Build next-gen developer tools and cloud infrastructure. Empower developers and everyone as we make software development more accessible.

https://github.com/serverless/serverless https://github.com/serverless/event-gateway

Apply - https://serverless.com/company/jobs

I'd personally use this to build some tools for a lot of AWS exclusive use-cases, in addition to multi-cloud stuff.

+1

Great points and good luck!

Good feedback. Didn't intend that. The goal was to give a personal perspective starting from the beginning of the serverless trend, to highlight why the effort is meaningful.

Lots. Docker, HashiCorp... It's the go-to-market strategy for lots of products now, especially developer tools.

Awesome project :)

Serverless, Inc | Full-time | SF or Remote (US, Canada, Europe) | serverless.com

We started with the open-source Serverless Framework (http://www.serverless.com), we raised a great seed round, and now we're building more awesome tooling to help individuals and teams build serverless, event-driven architectures using AWS Lambda, Google CloudFunctions, Azure Functions and more.

We're looking for the following: • Node.js/Go engineers w/ devops expertise • Front-end/react engineers • Developer evangelists

Why this is a unique opportunity: • We're seeking to define the future of application delivery, not follow someone else's lead • Work w/ cutting-edge tech all day long • Our team is (very) small and you would be getting in super early • The VC firms backing us are behind the best developer companies of all time • Liberal, remote culture, based on trust • Open-source centric • Lots of traction

Contact us at jobs@serverless.com or ping us in gitter: https://gitter.im/serverless/serverless

Awesome, Localytics :) You are doing great work and you have also been super helpful in the Serverless Framework community. Thank you!

Serverless, Inc. | Remote or Bay Area | React Engineers/AWS Infrastructure Engineers

Last year, we began building the first serverless application framework (http://www.serverless.com), enabling developers to build web, mobile and IoT applications exclusively on event-driven infrastructure like AWS Lambda. Since then, we’ve been on the front page of Hacker News several times, collected around 7,000 Github stars and we've been funded by one of the top VC firms in the cloud infrastructure space (we’ll announce who soon).

Now, we’re doing something bigger. We’re looking for seasoned AWS infrastructure and React engineers to build a secretive, ambitious project that will potentially have a large impact on application delivery and open-source in general.

Though our company, and this project in particular, you will use cutting-edge technologies like AWS Lambda and GraphQL to solve longstanding problems with application delivery. Together, we will define new serverless/event-driven architectural paradigms, and help all developers deliver scalable applications, efficiently. This is a fantastic experience if you are forward-looking and ambitious.

team@serverless.com

Check out the Serverless Framework if you are looking to build entire applications on lambda - http://www.serverless.com

API Gateway has DDoS protection.

Serverless Framework - It's an open-source application framework for building web, mobile and IoT applications exclusively on Lambda and API Gateway. Lambda only charges you when it's run and scales automatically out of the box. Further, the project is well-funded and backed by a full-time team. http://www.serverless.com

Awesome!

The Serverless Framework - Open-source application framework that allows you to create serverless backends with AWS Lambda and AWS API Gateway. Lambda only charges you when your code runs and auto-scales out-of-the-box.

https://github.com/serverless/serverless

Working on it :) We are hacking away full time on the Serverless Framework and have some big features coming in the next few days.