It was a sunny morning last Friday in Toronto. Instead of enjoying the sun doing some outdoor activities I choose to join a group of people to talk about functions as a service at the Functions17 event:
Back in 2014, I noticed a new offering from AWS: AWS Lambda At the time, I was playing with Docker. The idea of not having a VM but just the important parts I need to run my application was very appealing to me, but what if I didn’t need to have even a container. In the end, what I need is something to run my code in response to an event that could be an HTTP request or something else like a message on a queue. This code will have some side effects for sure; so, we are not talking about “pure” functions here. We are talking about on how to organize your application with enough flexibility to scale at a function level. The time went by, and this serverless/function-as-a-service[FaaS] space start growing. I had the pleasure to learn more about how things are moving in the direction of having less infrastructure. This is a fundamental concept and a bit of misunderstanding regarding Function-as-a-Service. It is not serverless. The servers will continue to be there, but we are going to use another level of abstraction on top of them.
In the beginning, we had a physical server, and we need to deal with everything there. Even when developers sometimes didn’t need to work directly with those servers, there were/are teams dedicated just to maintain the server. Things don’t run by them self (or they do until they break). The second step was virtualization. We continue to have a physical server on-premise or on a cloud provider, but we don’t work directly with the hardware. There is an abstraction layer, the hypervisor, but we continue to handle them more or less as a physical server. The third step was/is containers. We can optimize the hardware by using just the amount of OS we need to run our app. There is more density to gain with this approach and less old headaches (and new problems as usual). People realize a single container is not your system and the interaction between all these containers could be tricky. You still need to manage them. Orchestration needs to happen, and platforms like Kubernetes and Docker Swarm emerge. Nevertheless, it is an improvement over a barebone server. The fourth step could be Function-as-a-Service. With this approach, developers can focus even more on the task at hand. It could be broken down into smaller tasks that will be deployed independently and scale on their own needs. If it sounds interesting to you here is the link to the conference play list #Functions17.
We had seven live presentations. Here are few comments on each of them:
FaaS tooling - Where we’re at & signs of change by Kassandra Perch. She presents an evolution on the tooling around FaaS with IO Pipe, an application performance monitoring for AWS Lambda, highlighting some of the challenges found when you have such a loosely coupled architecture.
Developer Velocity - Introduction to Function-First Development by Keith Horwood. This presentation put a lot of emphasis on productivity and how it is possible to iterate faster using a FaaS approach featuring StdLib, a FaaS library on Node.js.
Building Serverless Applications on Azure by Joe Raio. Presenting Microsoft Azure Functions in a clear and concise matter, Joe’s presentation shown how Microsoft had changed in the last few years to be able to adapt to new technology trends like FaaS. It was apparent the tooling and integration there will lead to a good productivity as long as you stay within Azure at least.
Twelve Factor Serverless Applications by Chris Munns. Chris’s presentation explains how the [Twelve-Factor App] principles are mapped to a FaaS implementation. It was amazing to see how well they are aligned but not too surprising as these are emerging ideas to overcome the problems we all have when those principles are not applied.
Spring Cloud Function & Infrastructure models by Adib Saikali and Stuart Charlton. Pivotal and Spring Cloud could not be out of ideas in this field. This presentation proposes different models of virtualization and FaaS as one of them. This time with support to multiple cloud providers and Java as the language of choice.
Building serverless applications with Apache OpenWhisk by Daniel Krook. IBM Bluemix is a cloud provider some people would oversee, but in this presentation, it is evident they are moving fast in the cloud arena. Apache OpenWhisk is an interesting open source FaaS cloud platform where the event driven approach is your programming model.
Serverless Peanut Butter and Jelly - GCP and Firebase by Sandeep Dinesh. Even when Google’s Cloud Functions is still in beta, this could be a beta as Gmail was in beta for years but working without problems. It was an excellent presentation on how that platform is working right now in combination with other parts of Google Cloud. In this case: Firebase and Data Lost Prevention API.
I enjoyed this conference. It was very well organized and I appreciate the time and effort dedicated to it by its organizers:
I hope they continue to put together conferences like this one. This is just the beginning of FaaS. It is a new approach to what we do every day. Hopefully, the challenges of today will be part of the past soon.