Fission

New Features in Fission: Health Check, Authentication & Much More

Tue, 24 May 2022 01:05:00 -0700

The best part of being an open source project is that there so many opportunities to improve. People from all over the world come together and contribute to make a project better. And we’re thankful to our amazing community that has helped us make Fission better over time. We are happy to announce a new version of Fission - v1.16.0 that brings exciting new features, bug fixes and enhancements.

In this blog post, I’ll throw light on these features and how you can use them.

4 Reasons to Choose Fission Kubernetes Serverless Framework

Wed, 23 Mar 2022 08:30:34 +0530

The Serverless paradigm is empowering developers to focus only on building the application and not worry about anything else. Kubernetes has become an industry standard for hosting cloud native or container based microservice applications. It works seamlessly across public/private clouds and provides a common platform without any vendor lock-in. Hence, it makes naturally a good choice to build serverless frameworks on top of Kubernetes.

There are a handful of Kubernetes serverless frameworks out there and Fission is one of the popular ones.

Demystifying Fission - HTTP Requests in Fission

Thu, 17 Mar 2022 09:30:34 +0530

The first ever message that was sent from one computer to another was “lo” on the ARPRANET in 1969. That one message was a stepping stone to the modern day emails, instant messages and the Internet. In today’s blog post in our Demystifying Fission series, we are going to talk about how Fission handles HTTP requests and routes them to functions.

But before we dive into it, let us do some revision, shall we?

Demystifying Fission - New Deploy

Thu, 10 Feb 2022 11:30:34 +0530

Times change and technologies evolve. The serverless architecture has been around for quite some time now as an option to deploy applications to the cloud. Most of the mainstream cloud providers launched their Function as a Service offerings about a decade ago.

Fun Fact: Did you know that Amazon’s Alexa Skills are entirely running on AWS Lambda functions? All of Alexa’s skills are hosted on Lambda functions which are perfect for the use case. They need functions to load quickly and don’t need to store any state.

Demystifying Fission - Pool Manager

Mon, 07 Feb 2022 11:30:34 +0530

As the demand for faster shipping increased, the software development process and tools were also streamlined. With CI/CD developers don’t really have to worry about integrating, building and deploying their code. With serverless they don’t need to worry about the environment and infrastructure at all. Serverless is the present and the future of the software development process.

Function as a Service

Serverless today isn’t a buzzword anymore, it’s fairly mainstream to say. From spinning up VMs in the cloud to storing data and executing functions, serverless is a sea today. Function as a Service (FaaS) is one of the key components of the serverless world that is helping developers focus only on their code. All the cloud service providers have the FaaS offering with different names and similar features.

Function builders also support PodSpec now

Fri, 01 Nov 2019 12:39:32 +0530

In a previous post we discussed about how we can leverage PodSpec in the environment pods to enable the functionalities like tolerations, nodeSelectors, volumes, security and a lot others. That functionality was only supported in the environment pods, but now we can provide the podspec in the builder pods as well. The details about what PodSpec is and the functionalities that it enables are described in the mentioned post.

In this post we will be looking into how do we use PodSpec in builder so that the deployment that will be created for the builder will have podspec that we mention in the environment for builder. If we take a look at below environment spec

apiVersion: fission.io/v1
kind: Environment
metadata:
 creationTimestamp: null
 name: python-env
 namespace: default
spec:
 builder:
 command: build
 image: ghcr.io/fission/python-builder
 keeparchive: false
 poolsize: 3
 resources: {}
 runtime:
 image: ghcr.io/fission/python-env
 terminationGracePeriod: 360
 version: 2

Setting Ingress for your Functions

Mon, 28 Oct 2019 22:09:38 +0800

Some exciting updates to ingress host path, annotations, and TLS support. In Fission version 1.6.0, which was released on Friday 11 October 2019, new features arrived. This blogpost covers the exciting updates to ingress host path, annotations, and TLS support.

Fission previously supported ingress. However, it lacked support for TLS, host field, and ingress annotations. Now with version 1.6, all three are supported.

In this blog post, we will cover all three of the new features. But first, let’s talk about ingress some more.

Functions On Steroids With PodSpec

Mon, 20 May 2019 13:41:33 +0530

There are features which enable a specific new functionality and then there are features which enable a whole new class of functionality in a product. I am excited to share that PodSpec is now available in Fission. Fission functions can be extended to do many things with PodSpec - such as tolerations, volumes, security context, and more.

Previously, Fission had support for “container specs” - which allowed you to add environment variables, etc. to functions. With PodSpec - a whole spectrum of new possibilities are now unlocked. While “container spec” still exists for backward compatibility, we recommend using PodSpec for extending your Fission functions moving forward. In this tutorial we will walk through various use cases and working examples with PodSpec.

New in Fission: Live-Reload, Canary Deployments, Prometheus integration

Tue, 16 Oct 2018 01:05:00 -0700

Today we’re really excited to launch a set of new features for Fission, our open source Kubernetes-native serverless framework. These features are all designed to help you improve the quality and reliability of your serverless applications on Kubernetes.

Serverless architectures have obvious productivity advantages. You can get your apps up and running quickly, reducing the total lead time to ship your new application. However, to make this “production ready”, serverless architecture needs to be not just about moving fast, but also about moving fast safely, and at scale. That means we need features focused on code quality, testing, better deployment and release practices.

Live-Reload in Fission: Instant feedback on your Serverless Functions

Tue, 16 Oct 2018 01:04:00 -0700

Accelerating feedback loops are an important devops principle: the sooner you find a bug, the cheaper it is to fix it.

While developing your application, you’re typically going through a cycle: write code, build, deploy into a test environment, run tests, fix, repeat. The build and deploy stages of this cycle are idle, unproductive time where you’re simply waiting. As a project grows, these stages get slower and slower. Once they’re slow enough, you end up context switching to another task, while waiting, and that makes it harder to get back into the right context and fix any bugs you find in testing.

Using Fission's Prometheus Metrics

Tue, 16 Oct 2018 01:01:00 -0700

You can’t improve what you can’t measure. Visibility into metrics is a foundational requirement for much of software operations.

Serverless metrics collection can be tricky. For one, there is no “uptime” to measure. Secondly, with a “pull model” like Prometheus, there is no long-lived service to scrape metrics from. By the time Prometheus scrapes your function’s running instance, it may already be terminated, since functions are short-lived. Though Prometheus has a push gateway, it doesn’t maintain history, which makes it hard to track metrics for multiple concurrent function instances.

Function Composition: What It Means, and Why You Should Care

Fri, 08 Jun 2018 11:39:15 -0700

FaaS Functions give you the ability to quickly deploy services made of small functionality. But any more complex use case requires multiple functions. What are the different approaches to this? What are the parameters on the basis of which we should compare these approaches?

In this short blog post, I’ll briefly go over the significance of function composition and why you should care about it.

First off, What is Function Composition

Function composition refers to combining single functions to create bigger, more complex functions. I like to think of it as creating “super function combinations” in order to gain more dynamic and effective functionality – each function being a building block in the orchestration of an application’s data and/or control flow.

Function Composition in a Serverless World [Video]

Mon, 14 May 2018 09:16:30 -0700

Earlier this month, Software Engineer Erwin van Eyk and Developer Advocate Timirah James gave an awesome talk on function composition at KubeCon EU in Copenhagen, Denmark. The talk covered 5 serverless function composition styles and the significance of function composition when deploying serverless functions.

You can view and download the slides here, or you can check out the video below.

What’s FaaS?

FaaS is FaaS of course is functions as a service and FaaS frameworks allow developers to deploy individual parts of an application on an as-needed basis.

Getting Started: Composing Serverless Functions with Fission Workflows (Part 2)

Thu, 05 Apr 2018 14:15:37 -0700

This is the second half of a 2-part introduction to Fission Workflows.

In part One of this series, we talked about the concepts around Fission Workflows, how to create them, as well as a few demos of use cases in which you might use them.

So we’ve gone over what workflows are, along with when, and how to execute them. In this blog post we’ll dive deeper, breaking down each component that makes up the fabric of workflows, and what make workflows so efficient.

Getting Started: Composing Serverless Functions with Fission Workflows (Part 1)

Tue, 27 Mar 2018 04:25:55 -0700

This is the first of a 2-part introduction to Fission Workflows.

Fission provides fast serverless functions on Kubernetes. While functions are great for specific pieces of business logic, any non-trivial application requires a composition of functions.

There are many ways to compose functions. You can directly call functions from each other — but there are some disadvantages to this. For one, the structure of the application becomes hard to understand; dependencies are not obvious; essentially, every function becomes an API. Second, there’s no persistent state; if there’s a failure or exception and you want to retry, the whole function must run again.