Fission Blog on Fission

Running GPU based Functions on Fission

Thu, 26 Sep 2024 00:00:34 +0530

With new advancements in AI, more people want to use GPU-based functions in serverless environments. Fission is a serverless framework that you can easily deploy on your Kubernetes clusters.

Fission helps users run their models for different tasks, such as image processing, video processing, and natural language processing. Sometimes, you need special accelerators like GPUs to run these functions effectively. In this guide, we will show you how to set up a GPU-enabled Fission environment and use it to run your GPU-based functions.

Building a Serverless URL Shortener with MongoDB Atlas and Fission

Mon, 20 Feb 2023 09:30:34 +0530

A few weeks ago, I delivered a talk on Demystifying Serverless at the MongDB meetup here in Hyderabad. As part of the talk, I also showed a hands-on demo of using Fission with MongoDB Atlas. In this blog post, I’ll talk about building a serverless URL shortener using MongoDB Atlas and Fission serverless framework.

URL Shortener with MongoDB Atlas and Fission

We will create a URL Shortener application using Fission functions. It will have two functions, one for the frontend and the other for the backend to shorten the URL & communicate with MongoDB Atlas.

Fission Function Orchestration with Argo Workflows

Thu, 22 Sep 2022 12:22:07 +0530

Fission Functions allow user to perform one logical task. To group multiple task together such as one function is dependent on other we can use Argo Workflows.

Argo Workflows is an open source container-native workflow engine with a feature to create DAGs i.e. running task sequentially, in parallel and with dependencies. We will try to develop a simple Insurance Eligibility program which will take different input and calculate insurance installment on basis of the inputs.

Virus scan MinIO buckets using ClamAV, Fission and Kafka

Mon, 01 Aug 2022 09:30:34 +0530

All organizations want to protect their systems and have a good strategy in order to stay away from malware or other potential threats. Before introducing files and binaries into your system organization is very important to scan them and respond immediately based on a predefined strategy.

About Fission

Fission is an open-source and Kubernetes-native serverless framework that lets developers to run code functions easily. Kubernetes has powerful orchestration capabilities to manage and schedule containers while Fission takes advantage of them, being flexible. In other words, Fission can focus on developing the function-as-a-service (FaaS) features.

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.

Autoscaling Serverless Functions with Custom Metrics

Wed, 11 May 2022 14:43:46 +0530

Autoscaling is one of the key features of Kubernetes because of its capability to scale up or down according to the load. This is pretty useful as optimizes cost with minimum human intervention. Autoscaling adjusts your applications and resources based on the rise and fall in the demand.

In the earlier versions of Fission, new deploy functions depended only on targetCPU metric for scaling. But what if you want the functions to scale based on some third party software’s metrics?

Fission Serverless Function + Zapier Webhook - Automate your workflows

Thu, 14 Apr 2022 11:35:34 +0530

There hasn’t been a greater need for automation than what it is today. Things around us are moving fast and everyone wants things done faster. Getting that agility manually is tough and hence individuals and teams globally look for ways to automate workflows.

In this post, I’m going to show you how you can automate your workflows using Fission serverless functions and Zapier Webhooks.

What is Zapier?

Zapier is one of the world’s most widely used tools to automate workflows. It allows you to integrate various apps that you use and integrate them along with actions to complete a flow.

Developing a Serverless Twitter Bot on Fission

Fri, 01 Apr 2022 11:30:34 +0530

Social Media can be extremely overwhelming whilst being useful. Twitter of all is one of the most hyperactive social media platforms. If you are an enterprise, most likely you’ll have tons of tweets and DMs to reply to. While there are off the shelf tools available to help you do that, there’s always some missing functionality.

So why not develop a solution on your own? In today’ post I’ll show you how to develop a serverless Twitter Bot running on Fission. The simple application will show you how to use Twitter API and deploy the bot as a serverless function in Fission on your Kubernetes cluster.

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?

Guestbook Application With Fission and CockroachDB

Tue, 08 Mar 2022 09:30:34 +0530

Fission provides you with a serverless framework that you can deploy on your Kubernetes clusters. There are various use cases where you can use Fission, and today we’ll show you how to develop a guestbook application with Fission in Go using CockroachDB as a database.

Serverless Guestbook Application

The guestbook is composed with four REST APIs and each API consist of a function and an HTTP trigger.
This application allows a user to create, edit and delete a message. You can submit a message, retrieve a list of messages, delete a message all by means of REST APIs. You can clone Fission REST API Repo and follow the guide to install/try guestbook sample.

8 Must Know Terms For A Serverless Developer

Thu, 03 Mar 2022 15:30:34 +0530

I’ve been a mobile developer for most of my professional career. The transition from Java to Android wasn’t a big deal. However, most of the mobile apps today have shifted their backend to serverless. This makes mobile apps more light-weight and improves their maintainability.

As I set out to build and learn more about serverless applications, I’d like to share my learnings with you. This post lists 8 terms you must know as a serverless developer.

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.

Single or Monolith Serverless Functions - What should you choose?

Wed, 09 Feb 2022 11:30:34 +0530

The term Software Engineering first appeared in the 1960s and today we have close to 27 million software developers across the globe. With our lives surrounded by apps, the need for quality software is growing. Afterall, better the code, better the app. Microservices and serverless are helping make applications more scalable and faster along with making their deployments easier.

However, there’s one question that most developers have today is whether to use single or monolith serverless functions in their applications. In this post, I will try to help answer that.

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.

Observability with OpenTelemetry & Datadog in Fission

Mon, 17 Jan 2022 06:30:34 +0530

Software development isn’t just about writing a piece of code and running it. There are a lot of other processes around it that ensure that your code is going to work as expected in the real world. Amongst all such practices, Observability is going to be our point of discussion today.

Observability is all about gaining greater control and visibility over your application. It actually tells you what is really happening in your application. With most of the applications today adopting a microservices-oriented architecture, the applications have become complex with a lot of moving parts. And hence observability is a key to build a robust and reliable system. Logs, Metrics and Trace are the 3 pillars of observability. While logs and metrics are very helpful, trace allows you to traverse the entire journey of a request.

How to use PostgreSQL database with Fission functions

Wed, 05 Jan 2022 11:30:34 +0530

How to use PostgreSQL database with Fission functions

In today’s blog post we will see how we can use Fission functions to connect to a PostgreSQL database and perform basic operations on it. By the end of this blog post, you would have learnt how to use PostgreSQL database with Fission functions.

Voting App using Fission functions with PostgreSQL Database

We will create a basic voting application that allows users to vote for an option and view the results. This application is written in Python and uses PostgreSQL database to store the results.

Serverless Next.js Example Blog with Fission

Wed, 17 Nov 2021 13:29:16 +0530

What is Next.js?

Next.js is a framework for building fast, modern websites using React. Next.js provides a couple of features for building static and server-side rendered websites. With Next.js examples and showcase, you can get a taste of Next.js. You can refer to the Next.js documentation for more details.

Next.js Example Blog with Fission

Next.js is gaining a lot of popularity in serverless world. Fission can be used to host a low traffic frontend website, with minimal cost and reduced maintenance. Fission can host your existing Next.js application with few modifications.

Serverless Kafka Consumer for Confluent Cloud

Wed, 10 Nov 2021 11:21:01 +0530

Confluent Cloud is a fully managed, cloud-native service for Apache Kafka. Managed Kafka offering helps you focus on connecting and processing data, anywhere you need it. You avoid hassle of infrastructure management.

In this blog post, we will connect with Kafka cluster hosted in Confluent Cloud using Fission Keda Kafka Connector with SASL SSL. Using Kafka Connector, we receive the latest messages on our desired Kafka topics and process them with Fission functions.

Kubernetes Response Engine: Falcosidekick + Fission

Wed, 01 Sep 2021 00:00:00 +0000

This blog was originally published on Falco website.

This blog post is part of a series of articles about how to create a Kubernetes response engine with Falco, Falcosidekick and a FaaS. The earlier posts in this series, show how to use Kubeless, Argo, Knative, and others to trigger a resource after getting input from Falcosidekick.

Recently, Falcosidekick received a new output type support for Fission.

In this blog post, we will cover using Falcosidekick and Fission to detect and delete a compromised pod in a Kubernetes cluster. We will briefly talk about Fission in this blog, however, you can check the complete documentation here.

Fission WebSocket Sample

Fri, 11 Jun 2021 10:50:51 +0530

Introduction

In this post we will look into how we can develop a simple a web socket based chat application using Fission functions. Fission’s NodeJS environment now has built in support for WebSocket. So, we are going to use this environment to power our simple web based chat application.

Let’s first understand how this is going to work.

We start by creating a NodeJS environment using the fission/nodejs-env Docker image.
Then we create a fission function for with broadcast.js. It is this piece of code that will broadcast a message to all connected clients.
Next, we will create an HTTP trigger for the above created function.
We then update our chat application to connect over the route, we just created.
We will also create a function to host the this chat application.
As you send a message from one chat window, the function will be triggered and the message will be broadcasted to all connected clients.

We will cover two approaches using which you can test this setup.

Headless Chrome with Puppeteer in a function

Sun, 09 May 2021 23:50:51 +0530

Introduction

Running chrome headless is useful for various test automation tasks but running a headless Chrome in Docker can be tricky (More details here). Also the this Github issue has some good insights on the issues you might face. This blog shows running headless chrome in a fission function. You can find the working example with code etc. in examples repo here.

Typical use cases for which Puppeteer is used are:

Generating screenshots of specific web pages
Automating form submission at scale or doing any testing of web pages
Testing of chrome extensions
Crawl web pages to gather information from them.

Demo

If you simply want to get a sense of running function run, assuming you have Fission installed, you can run fission spec apply and then then test the function

Penetration testing with Gobuster & Fission

Thu, 15 Apr 2021 15:57:51 +0530

Introduction

Gobuster is a tool for bruteforcing websites Directory/File, DNS and VHost written in Go. It enables penetration testing and and brute forcing for hackers and testers. In this tutorial we will use Gobuster with Fission’s binary environment to run it for specific sites and for specific patterns listed in a text file. Fission allows the teams doing penetration testing to focus on code and execution rather than understanding all things around infrastructure.

Using gVisor with Fission

Wed, 10 Feb 2021 18:09:02 +0530

Introduction

Have you ever run into a scenario where you had to run untrusted code? Containers are great from a performance perspective but they have a considerable access to the kernel which can be exploited. In order to have the security of VMs and speed of containers, projects like gVisor and kata containers have risen. In this post, we’ll take a look at gVisor provides an application kernel for containers. It provides a runtime which can be used by Kubernetes. To understand more about how gVisor provides security, please go through this.

Monitoring Fission logs with Grafana Loki

Mon, 14 Sep 2020 16:19:12 +0530

Importance of Logs

Proper logging in a software is a quick and systematic way to inform the state of the software. Although the definition of ’logs’ remains the same along years in software engineering, the scope of what logs are used is has always been increasing. Apart from helping developers and operators, logs can be used by complimenting software for security, metrics, triggers, cost estimation and other different operations.

Logs in Fission

Fission works in a systematic way where there are different services (containers) providing functionalities for running applications (Functions) in a serverless way. Logs in Fission thus comprise of log statements from these services as well as from the applications.

Event Driven Scaling Fission Function Using KEDA

Tue, 14 Jul 2020 18:09:02 +0530

Introduction

Events and integrations with event sources such as message queues are an important part of running functions. Fission had the MQ integration for invoking functions and this integration was available for Kafka, NATS, and Azure Queue Storage. This integration had a few limitations:

For every new integration you want to enable - there was one pod running for enabling the integration
Autoscaling of the trigger handler was not available.
Lastly - one Fission installation could connect to and handle only one instance of a MQ. So for example you could only connect to one Kafka instance in a given Fission installation.

When we decided to build out these features we came across KEDA project and it solved most of the limitations which Fission had in the event integration area. Let’s dive into how it works!

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! Fission GitHub Action: Easily Automate Your CI/CD Workflows

Thu, 25 Apr 2019 18:30:53 +0530

Introduction

GitHub recently launched GitHub Actions which enable developers to develop workflows and execute them based on events in code repositories such as a push event or an issue creation.

There are many Actions available on the Github marketplace which you can use for automating various tasks and workflows around development and deployment. In this tutorial we will use the recently launched Fission Action and build a simple workflow that deploys a Fission function to a Kubernetes cluster.

Monitor Fission serverless functions with OpenTracing

Fri, 22 Feb 2019 15:42:30 +0530

Introduction

As the number of functions and their usage grows, it is crucial to monitor and manage them effectively. Fission already supports logs on CLI as well integration with external systems using Fluentd. Fission also has monitoring enabled using Prometheus and provides a great way to measure and track your functions automatically.

Serverless functions can be part of a larger distributed system. For example, in the case of serverless applications that become more complex - spanning multiple functions, or in Microservices where functions are triggered between different services that talk to each other to process a single request or perform a business function.

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.

Automated Canary Deployments in Fission

Tue, 16 Oct 2018 01:02:00 +0000

Canary Deployments are a time-tested deployment strategy to reduce risk. The fundamental idea is that deploying software into a production cluster is different from releasing it to its users. With canary deployments, you deploy both old and new versions into a production environment, but send only a small percentage of traffic to the newer version. That way, if the new version fails, only a few users are affected rather than the application’s entire user base. If the newer version works well, the traffic proportion being sent to it is increased incrementally until the new version has been rolled out to all live traffic.

Fission Kafka Sample

Thu, 30 Aug 2018 22:50:51 +0530

Introduction

The open-source Apache Kafka is one of the most popular distributed Stream Processing platforms used for building real time streaming data pipelines and applications. To learn more about Kafka visit the Kafka documentation.

Most serverless functions are triggered by an event, and these in turn may trigger consequent events, which could invoke further functions. This makes Kafka - which acts as a event broker - a natural companion to a Functions-as-a-Service (FaaS) platform such as Fission.

Writing Serverless Functions for JVM with Fission.io

Thu, 30 Aug 2018 22:26:41 +0530

Introduction

The Java Virtual Machine (JVM) is one of the most popular application frameworks, particularly when it comes to enterprise software development - due to the maturity of JVM, the breadth of integrated developer tools and the vibrant community, and the extension of JVM to additional languages.

The historic data from TIOBE index also shows how popular JVM and Java have been through the years. In the last decade or so Scala and data-related technologies have made great progress using JVM as the base framework. Most recently Kotlin has seen great progress and also got blessings of Google as an official language for Android development.

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.

FaaS Function Composition with Fission Workflows and NATS

Thu, 22 Mar 2018 01:46:30 -0700

NATS is a lightweight, open source, high-performance, messaging system for cloud native applications, IOT messaging, and microservices architectures. The NATS messaging system implements a scalable publish-subscribe (or pub/sub) distribution model. There are a number of open source technologies like Kafka, and several cloud technologies such as Google Cloud Pub/Sub and Azure Service Bus that adopt this model as well.

In light of NATS recently being accepted into The Cloud Native Computing Foundation last week, we thought it’d be cool to share how Fission functions and workflows utilize this sleek messaging system on top of Kubernetes.

Hello World: Creating Functions using Fission (in Golang)

Mon, 05 Mar 2018 11:13:45 -0800

First, What is Serverless?

In the last blog post Kubernetes for Newbies, we went over how to get an application up and running on Kubernetes. Though Kubernetes is surely a hot topic in tech, the “serverless” space has become just as (if not even more) trendy. Why is serverless so popular in the dev community?

Turns out, serverless is a developer’s saving grace when it comes to managing servers. Instead of managing a bunch of servers, Serverless solutions allow developers to … well … not manage servers at all! Serverless completely takes away the burden of managing servers. One could say that Serverless separates the “ops” from devs. Functions as a Service (FaaS) enable developers to deploy parts of an application on an “as needed” basis using short-lived functions in just about any programming language.

Hello World in Go for Kubernetes Newbies

Tue, 20 Feb 2018 13:52:34 -0800

Over the past 3 or so years, it seems the term “containerization” and the name “Kubernetes” have been amplified throughout the tech community non-stop. Even with that being so, as a developer, it can be easy to shy away from Kubernetes as its learning curve is notorious for being a steep one. But everyone’s gotta start somewhere, right? This tutorial will give you a basic overview of some of main features of Kubernetes, while walking you through the process of running a simple HelloWorld Golang application locally on your machine to running it on Kubernetes.