Skip to main content
Adopting Serverless Computing with TIBCO & AWS
  1. Blog/

Adopting Serverless Computing with TIBCO & AWS

·4 mins·

As the AI-fueled, edge-exposed, blockchain-driven, and streaming analytics-enabled use cases of the future move closer into view, new technologies are needed to make the vision real. Unique and complex workloads accompany the use cases of the future, but luckily, the enabling technologies to compute those workloads have already arrived.

Join TIBCO and AWS for an exciting webinar to help you better understand what serverless architecture is all about,  and the benefits of running your apps in a serverless environment. Before you give a listen, how about a quick introduction?

So, what is serverless computing anyway?

Serverless is the utilization of a compute platform to run code without provisioning or managing servers. Serverless can be utilized for nearly any type of application or backend service but there are certain use cases that work need auto-scaling capabilities both for high availability and for economics. Some of the most common use cases for serverless include ecommerce, mobile back-ends,  streaming data analytics, chatbots and AI, and IT process automation.

Why should I utilize serverless for my application deployment?

Building serverless applications means that you can focus on your customers and your product, and not worry about servers, volume spikes, run-times, or even up-times. In short, zero administration. The servers do still exist, but as a developer, you don’t have to think about those servers. You just focus on code, which gives you more deployment agility. In the world of cloud, you pay for what you use, as opposed to deployed parallel instances of your environment as a fail-safe. This can be up to a 90% savings over a VM, as you never pay for idle. Serverless unlocks new business models for the enterprise based on its ability to execute only the code function runtimes when triggered by an event. Enter: Function-as-a-Service (FaaS).

What’s the relationship between FaaS and serverless?

FaaS describes the capability to deploy an individual “function”, action, or piece of business logic using serverless architecture. They are expected to start within milliseconds and process individual requests; then the process ends and your function no longer uses any resources, potentially saving your business millions while maintaining the load balancing, instant scaling, and high-availability you need. FaaS is the breakthrough enabler to the event-driven architectures that enterprises need, in order to take action on events occurring in real-time.

How can TIBCO help in your voyage into the world of serverless?

Serverless applications must be lightweight and highly performant to deliver on business value. TIBCO’s open source Project Flogo® was written entirely in Golang with the goal of running microservices in the smallest possible footprint. We’ve seen services built with Flogo® up to 50x smaller than comparable services built using different frameworks.

The Flogo® framework is designed around single units of executable work, called a flow. A flow can be thought of as a function, and executes a specific set of tasks. Flogo®  was the first serverless integration framework to work with AWS Lambda functions, and Flogo®  has recently released fully-native Lambda capabilities to take full advantage of the newly introduced Golang support from AWS.

Ultimately, what this unique combination of AWS Lambda and Project Flogo®  means for organizations is the ability to build and deploy functions faster than ever before, with economics of a pay-as-you-go AWS pricing model that enables an entirely new world of use cases.

Get smarter about serverless

You’ve heard a bit about the benefits of serverless and FaaS and how TIBCO’s toolset can help you with that transition. For a deeper dive and a better understanding of the use cases, tools and support from TIBCO and AWS, listen to our exciting webinar discussing:

  • Serverless technology and the art of the possible
  • Monolith to microservices to functions
  • The evolution to event-driven architecture
  • The best features in AWS Lambda
  • What TIBCO is doing to support your transition to serverless

Are you ready to join the market leaders in the new world of serverless? Let TIBCO and AWS help take you there.

Originally published on www.tibco.com

Related

Serverless and Flogo - A Perfect Match

·5 mins
I get to work with serverless microservices on a daily basis, those are services I use myself and ones I help our customers build to take advantage of the benefits that serverless brings you. With many services needing to be deployed and continuous updates, I found myself doing the same thing over and over. It is that specific task that frustrates me most; it simply wasn’t as seamless as I thought it could be. In this article, I’ll walk you through how I cut the development time and make deployments easily repeatable like a walk in the park — thanks to the combination of the Serverless Framework and a tool called Project Flogo.

What Do I Do In Between re:Invent Live Streams? Build Lambda functions

·5 mins
This year I wasn’t able to attend re:Invent, but I did want to do something nice in between the live streams and specifically around Serverless compute and AWS Lambda. Lambda lets you run code without provisioning or managing servers. You pay only for the compute time you consume — there is no charge when your code is not running. With Lambda, you can run code for virtually any type of application or backend service — all with zero administration. Just upload your code and Lambda takes care of everything required to run and scale your code with high availability.

A Visual Approach To Building And Deploying Microservices

·1 min
Together with the O’Reilly team, I did a webinar on visually building microservices. Modern digital experiences run on microservices, but building them isn’t always straightforward — especially if you’re not deep in the weeds of API specs and Swagger definitions. The core questions we tackled: how do you let developers and architects visually define an API without needing to be Swagger experts? And once you’ve built your microservices, how do you deploy the same project to a private cloud, a public cloud, and on-prem without reworking everything?