DEV Community: nimbella

No infrastructure, just code. Learn the simplicity of serverless

nimbella — Thu, 26 Aug 2021 06:00:52 +0000

[guide on how to build and deploy an app using Nimbella Serverless platform]

The Nimbella platform unifies the programming experience for the cloud with a serverless foundation. In this way, developers can deliver a complete and integrated solution that is enterprise-ready and multi-cloud ready. Nimbella is designed from the ground up to address the needs of event-based applications, long-running applications, stateful workloads, and more complex use cases including artificial intelligence and machine learning.

What is serverless?

Serverless is a cloud-native development model that allows developers to build and run applications without having to manage cloud infrastructure like servers.

There are still servers in serverless, but they are abstracted away from app development. A cloud provider handles the routine work of provisioning, maintaining, and scaling the server infrastructure. Developers can simply package their code in containers for deployment.

Once deployed, serverless apps respond to demand and automatically scale up and down as needed. Serverless offerings from public cloud providers are usually metered on-demand through an event-driven execution model. As a result, when a serverless function is sitting idle, it doesn’t cost anything.

Nimbella is a serverless cloud that helps developers and organizations adopt a cloud strategy focused on rapidly delivering business value in a changing cloud landscape. Nimbella is backed by proven enterprise-grade open source software and offers organizations the peace of mind of being able to run across multiple clouds, including private infrastructure.

Prerequisites

To complete this tutorial, you will need a Nimbella account. If you don’t have an existing account, visit the Nimbella Signup page and create an account for free.

Steps to build and deploy an app using Nimbella Serverless platform

Step 1: Downloading the Nimbella CLI

Let us install the Nimbella CLI by following the instructions provided in the nimbella documentation.
To verify whether the nimbella CLI is installed or not, let's open a command prompt (or Terminal), and enter the following:

Step 2: Connecting Nimbella CLI to your account

Once the CLI is installed we need to link it to our Nimbella account for that reason we can use auth command in the nimbella CLI.
Some of the features provided by auth command are listed below details
Now to connect the CLI to our Nimbella account we will be running the following command in the terminal.
The above command will open our default browser for authentication once that is done our account will be connected. ### Step 3: Creating our project
To create a project we will use the project command with the following syntax:
Nimbella supports different languages, So we can choose anyone from the below list:
Create a project folder with the name my-first-project and language as javascript by running the below command in the terminal.
As we can see our project has a fixed directory structure, which determines how projects are deployed. The below diagram summarizes the directory structure of an individual project with no project configuration.
The hello.js is a file pre-filled with hello function (action) written in JavaScript which we will deploy in the next step.

Step 4: Deploying our project

As we can see, our project is deployed on the nimbella serverless cloud. We can retrieve the URL for any particular web action by using the action get command, as in the following example, which returns the URL for the hello action created before.
Now if we navigate to the above URL in our web browser, we can see the following webpage:
We can also use the project deploy command with a list of projects in a single invocation to deploy them all at once (e.g., nim project deploy example1 example2 … ).
All the actions we have deployed will be stored in our Nimbella Account, we can retrieve that list by using the action list command:
Whenever we deploy a project or invoke an action, a unique activation id will be generated which will be linked to that action.
We can use the activation list command to list the data of all activations which also include Status, Activation ID, Duration of the activations.
Datetime Status Kind Version Activation ID Start Wait Init Duration Entity
The Activation ID in the above output will help us in retrieving the result, logs, and data of any particular action we deployed, to do that we can use the following commands:

Step 5: Creating an action

Instead of creating a project we can also simply create an action and deploy it. This action can be directly invoked, updated, and deleted using the Nimbella CLI.
Let's create an action by following the below steps:
Copy the code following into a file and save it as hello_stranger.js
Now to deploy this action onto our account type the following command in your terminal: Using the above command the action will be deployed privately, to deploy it in public use the "--web=true" flag along with the command We have successfully deployed our action using the nimbella CLI.
Let's modify our hello_stranger function with the below code to take place as an input parameter:
Now to update the code on nimbella we will use the following "update" command:
To fetch the output of the hello_stranger action, Let's use the invoke-command. We can also provide the input parameters to the action using the "-p" flag as shown in the following example: Not only that we can also delete, get data of action using delete and get commands.

Step 6: Project watch

Nimbella also supports incremental deployment of our project, which means whenever we modify and code or file in our project the watch feature will automatically deploy our modified project to the cloud platform
Let start the watch feature on our project by using the below steps:
Enter the following command in your terminal.
Let's try to do some small modifications to our code and check the output
As we can see, only the files which we modified are getting deployed instead of the whole project.
This feature will be a lot helpful for developers who constantly need to update and deploy their code.

Summary

Congratulations! We successfully built and deployed serverless functions, projects that can be invoked from the browser or microservices – all just by using CLI.

References

https://www.redhat.com/en/topics/cloud-native-apps/what-is-serverless

Author: G. Sai Dheeraj
Dheeraj is currently pursuing his Bachelor of Technology in Computer Science and is a bug bounty hunter. He is working on becoming a cybersecurity expert and spends most of his time reading articles about security and improving his skills in pentesting. In his free time, you will find him testing his skills through competitive programming and writing tech articles.

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

How to Migrate from Containers to Nimbella Serverless Architecture

nimbella — Fri, 30 Jul 2021 11:37:21 +0000

Serverless and containers are different cloud application development approaches that can enable faster and more reliable deployment of web applications.

In this article, we shall learn about container deployment, serverless deployment, and the steps & benefits of migrating containers to the Nimbella serverless platform.

Prerequisites:

Knowledge of HTML, CSS & JavaScript
Basic Knowledge of Serverless architecture
Node & Docker installed on the local development machine

What are containers?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. Thus, containers make sure that software runs correctly when it is moved from one computing environment to another. The image below depicts how apps get deployed in a containerized environment. Docker Container Documentation explains it in detail.

What is serverless?

Serverless computing is a cloud computing execution model in which the cloud provider runs the server, and dynamically manages the allocation of machine resources. Pricing is based on the actual amount of resources consumed by an application, rather than on pre-purchased units of capacity.

Why containers and serverless are related but different?

The below image illustrates how serverless and containers are related but different.

When is serverless better than containers?

Serverless offers the following over containers and is well suited in such cases.

Fast-growing apps requiring quick deployments and changes
Serverless is a pay-per-request model and can be inherited when traffic is unpredictable, results in cost-effectiveness
There’s no worry about scalability since a serverless provider manages it
Deployment simplicity is what makes Serverless incredible. There’s no administration of infrastructure needed

When containers are better than serverless?

Serverless has restrictions in terms of memory and size. Hence containers are preferred for long-running processes. Serverless provides a decreased start-up time and latency when compared to containers.

Let’s learn container deployment and then the steps to deploy the same app on Nimbella serverless platform by deploying a developer portfolio website on both with the below steps.

The below diagram depicts the architecture of our portfolio app.

Step 1: Creating a simple App (Developer Portfolio site with React.js & Node.js)

GitHub Source:
https://github.com/boltathi24/Dockerized_Developer_Portfolio_React_Node/

Please consider that we are going to create a developer portfolio website using React.js as front-end, Node.js as the back-end, and MongoDB as Data Storage.

React.js as Front-End:
Let's create our react app to bring the below to fruition.

A clean UI to depict the skills and uniqueness of a Developer.
A contact me form to collect visitor queries. We can create React boilerplate code by running below in the terminal.

npx create-react-app {appName}

Once created, let’s modify and design our front-end in the usual React.js way using React Components as below.

Let us create an API that stores the queries from visitors using Node.js as below.
Node.js Back-end:
Please consider that we are going to store the queries into a free cloud MongoDB instance.
Let’s initiate the project by running the below command in the terminal.

npm init -y

We need to install express (for creating server-side web applications), mongoose (to interact with MongoDB) by running the below command in the terminal.

npm install express mongoose

Let's code the logic to store the queries into DB as below.
https://gist.github.com/boltathi24/0c750f8e382051e6dcec184ea930e92b

Step 2: Running the app in Docker Container

We can run our app on docker with the below steps.

Create a Dockerfile (contains command line to assemble an image) Dockerfile for Express API: https://gist.github.com/boltathi24/f0e30e2bbe54fdf632444408e7c2fb96 Dockerfile for React App: https://gist.github.com/boltathi24/54baf4ab6d338869176bddc2007b5a35
Define services in a docker-compose.yml file (include above docker file inside this yml configuration) docker-compose.yml for Express API: https://gist.github.com/boltathi24/130aa62c27e70f795ed0f7ab2fe44678 docker-compose.yml for React App: https://gist.github.com/boltathi24/378412fd1a8ce9a40702295fd9a1df0f
Build and run your app with the Docker Compose tool We can run our React & Express App in a container by running the below command from the respective docker-compose.yml file directory.

docker-compose up -d

We can see our react app live on the port specified in Dockerfile.
We can ensure the same by running the below docker command.

docker ps

Now, We have created the developer portfolio app and deployed it inside a container. Let's learn how we can do the same with Nimbella Serverless.

Running App on Serverless:

Step 3: Creating a new account on Nimbella

Let’s do the below steps to get started with the Nimbella platform for deployment in 2 mins.

Create an account in Nimbella
Install nim CLI
Login to nim CLI with the below command

nim login

We are a step away from deploying our app in Nimbella. We need to modify the directory structure.

Step 4: Updating the app for Nimbella

As per Nimbella’s Deployment Standard, the back-end/actions code for API has to be placed under a directory named “packages” and front-end/static code into a directory named "web".

Please follow the below steps to migrate our *React App to Nimbella *

Wrap the React/front-end code inside the directory named web
Create build.sh and specify below commands inside to build the React App https://gist.github.com/boltathi24/023ccfe738961411e7740fc47d3e7c3d
Create .include file and specify “build” inside as the Build directory of our React App is identified with this file https://gist.github.com/boltathi24/a0c35ee33f6f83d6a17335a8efcee6bf

Please follow the below steps to Migrate our Node.js based App to Nimbella

In brief, we would have coded our business logic inside the routes specified in Express.

To migrate to Nimbella, we just need to wrap the same business logic inside the main function as below.
https://gist.github.com/boltathi24/9ced4d6bd82b4498dbfa4ac89ad50029

Please note that in express, we have specified the desired URL path inside the Routes But in Nimbella, the directory name represents endpoints, once deployed. Hence the directory name needs to be created with the name of the endpoints we would like to have in our API.

To migrate the express app to Nimbella, create a directory named packages.

Inside packages, create a directory that represents the app name as “form”.

Inside the app directory, create another directory as “insert” that represents serverless action. Now copy the serverless function which we have written inside the serverless action directory.

The below diagram depicts the directory structure on the Nimbella platform.

Our app’s final directory after modifying the directory as specified looks as below.

Step 5: Running/Testing the app

Create a project.yml file and configure it for deployment as below.

Let’s make our app live by running the below command.

nim project deploy {application’s directory} --env={path of environment file}

Our App and API are deployed successfully into the Nimbella Serverless Platform as below.

As per the above execution log, we can access our app with the below URL→ https://dlrowtlo-jyam4452nxf-apigcp.Nimbella.io/
You can get your serverless URL of Serverless action/API by running the below.

nim action get {actionName} --url

We have successfully migrated a developer portfolio app from containers to Nimbella Serverless Platform and the app can be accessed at the link below.
https://dlrowtlo-jyam4452nxf-apigcp.Nimbella.io/

Github Source: https://github.com/boltathi24/Nimbella_Developer_Portfolio_React_Node

TL;DR
Serverless and containers came into existence as an evolution towards maximizing utilization of computational power. We can migrate from containers to serverless with the below steps.

SignUp/Login to Nimbella account by installing nim CLI.
Wrap the business logic used inside existing API methods as functions.
Modify the directory of existing code as per serverless standards.
Configure a project.yml file for serverless deployment.
Deploy into Nimbella using deploy command. ## Benefits for Migrating Containers to Nimbella Serverless
Zero administration yet provides high security to date.
The aforementioned scalability problem of containers is avoided.
By reducing the overhead complexity of infra, developers can focus more on business logic resulting in faster time to market with reliability.
Delivering code changes more frequently and reliably using CI/CD Pipeline.
No need to worry about scalability during unpredicted traffic.
Developers do not need to worry about purchasing, provisioning, and managing backend servers.
Pay per request model facilitates cost-effectiveness since you pay only when service is consumed by the user.
Dedicated secure domain.
Integrated key-value store.
Integrated object-store.
Integrated logging & monitoring.
Global CDN.
MultiCloud deployment and much more.

Nimbella is named a strong performer in the serverless world by Forrestor. Please feel free to check out how Nimbella spreads the power of serverless on CRN & Rishdot Research.

Author details: Athithan Raj P
Athithan started his career with Cognizant and experienced himself in the testing field primarily. Later he started getting involved in different fields like Development, Security, Content writing, etc. He now works with a reputed organization as a Software Development Engineer in Test where he is responsible for the product quality through Automation.

Follow him on Twitter: @raj_athithan

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

Kubernetes in simple words: explained by Eric Swildens

nimbella — Mon, 12 Jul 2021 06:14:00 +0000

Find the answers to the most commonly asked questions related to Kubernetes (k8s) explained simply.

In this blog post, Eric Swildens, Co-founder and Chief Architect at Nimbella, will explain Kubernetes and answer the most commonly asked questions in simple words that can be easily understood by junior developers, DevOps specialists, and even non-tech professionals.

Questions that have been answered in this blog post

If you want to know what is Kubernetes and why is it so trendy, check out the next most common FAQ’s we have answered here:

Kubernetes in simple words, using real-life examples.
How is Kubernetes different from Docker?
What are Kubernetes clusters?
What are some benefits of using Kubernetes?
What are some products built on top of Kubernetes?
What are some good ways of learning Kubernetes?

First and most important: what is Kubernetes?

Let us explain it in very simple words:

Kubernetes is a system that manages containers (containerized applications) where a container could be explained as a lightweight virtual machine. To build an application you need to build a bunch of containers and then use Kubernetes to manage those containers. This sounds like something very difficult and time-consuming, but the advantage is that Kubernetes can create and scale containers automatically and manage storage among all the containers.

Source Kubernetes.io

Suppose you are trying to build a company. You need multiple departments to run the company: CFO, call center, engineering team, marketing, sales, etc. Think of them as different kinds of containers. So Kubernetes has a file which has the description of all the containers and how they work together: sales work with marketing and marketing work with engineering and this is how everybody talks to each other. Then you tell Kubernetes to execute it, hire all “containers” and if one of them fails it will restart it and redo it.
That's a simple explanation of what Kubernetes is.

To get a broader picture about Kubernetes and get more information we suggest some resources to read and watch:

Latest Cloud Native Foundation surveys https://github.com/cncf/surveys
Google Cloud Tech Video: https://youtu.be/cC46cg5FFAM

Kubernetes and Docker: how do they work together

What is Docker?

Docker is a container engine that is used to create containers. Let’s make it even more simple: Docker is a type of container and Kubernetes manages (deploys) Docker Containers or other types of containers.

For example, you built a web search application and you have a container that contains a web server. When visitors connect to your website, they connect to the web server in the container to get content. Let’s say a lot of visitors start connecting to your web server.

Kubernetes can identify the increased traffic and create another container containing another web server.

Kubernetes can restart a container as it fails, kills a container if it doesn't work, can do rollouts, put more containers and manage the networking for containers.

What is a Kubernetes cluster?

A Kubernetes system with a full set of Kubernetes components is called a cluster. The cluster can run on actual physical machines (such as PCs or laptops) or as virtual machines. If you just have one machine and it’s running a full Kubernetes system then that is your Kubernetes cluster, and if you have two machines that are running the Kubernetes, those two machines host your Kubernetes cluster. The cluster can run on any combination of virtual and physical machines.

What are the benefits of using Kubernetes?

If you need just one container for your application there is no benefit of using Kubernetes. For example, if you have one employee in a company, there is no reason to have a company. You can just have that one employee work on his own and that's exactly similar to Kubernetes. So if you are a company and you have sales, engineering, and all the other departments, then you need to hire people and you also need to manage them.

Kubernetes allows you to manage multiple containers, scale up, scale down and restart them.

Here are some of the benefits that Kubernetes offers:

Kubernetes does load balancing when there is too much traffic.
Kubernetes helps you do some storage stuff with a disc.
Kubernetes eliminates many of the manual processes involved in deploying and scaling containerized applications and standardizes them.
Kubernetes orchestration allows you to build application services that span multiple containers, schedule containers across a cluster, scale those containers, and manage their health over time.
Kubernetes High-Availability is another benefit because if something fails, it will replace it and restart over.

Real-life examples of Kubernetes in more detail

When you are developing an application, you need

a database
a specialized server that you develop
a web server to look at the webpage.
a machine to run everything.

The first problem arrives when your traffic starts drastically growing. If it runs on a physical machine then the solution would be to get another machine, install the operating system on it and put all the stuff on it.

The second problem that you possibly need to solve - load balancing. The solution would be to get a load balancer.
Imagine that now we are getting more traffic so we fire up four more machines. If you manage that manually then you have to do a lot of work.

So this is where Kubernetes comes in:

You install Kubernetes

You describe processes and applications and:

if you have four machines it uses all four machines.
If you have 16 machines, it uses all 16 machines.

If you need another Kubernetes cluster, you shall have a description of how to deploy on Kubernetes and it would deploy it on the other cluster.

So Kubernetes allows you to create scalable web applications and use all sorts of different resources that are composed of different components.

So as a business case, you want to standardize how your application is deployed and developed and this is the way of describing all the services and processes that you need. Then you use a scalable system called - Kubernetes.

To give you an idea of how big these things can get and answer the next question:

What are some worldwide famous products built on top of Kubernetes?

Some well-known applications that are currently using Kubernetes are the following.

Netflix

Let’s take the example of Netflix. Netflix launches half a million containers and 200k clusters per day. It has grown from thousands of containers launched per week to three million launched per week. It hosts thousands of applications globally over these machines and they are deployed on virtual machines. Imagine having to manage all this manually 🤒🤒🤒. So such a size of workload is usually managed on Kubernetes.

Spotify

The next example is Spotify, a well-known audio streaming and media services provider with over 200 million users worldwide. The biggest service currently running on Kubernetes takes about 10 million requests per second as an aggregate service and benefits greatly from autoscaling, says Site Reliability Engineer James Wen.

Plus, he adds, "Before, teams would have to wait for an hour to create a new service and get an operational host to run it in production, but with Kubernetes, they can do that on the order of seconds and minutes." In addition, with Kubernetes's bin-packing and multi-tenancy capabilities, CPU utilization has improved on average two- to threefold.

Adidas

Another example is Adidas. Currently, 100% of the Adidas e-commerce sites are running on Kubernetes. With 4,000 pods, 200 nodes, and 80,000 builds per month, Adidas is now running 40% of its most critical, impactful systems on its cloud-native platform.

They drastically speed up the load time and releases went from every 4-6 weeks to 3-4 times a day. With Kubernetes, they solved the problem of getting quick access to all developer tools.

Kubernetes made easy has a name: Nimbella

However, Kubernetes is a bit complex: if you are a developer and you want to run some code in Kubernetes, you have to figure out the orchestration and learn more.

In such a case Nimbella could offer ease of development, so that means you get the benefits of Kubernetes without the hassle of having to go in-depth into it.

That's the way Nimbella works and what Nimbella offers. That's called scale to zero. In Kubernetes, that's not true. You have all these containers and even if nothing is going early-stage on, containers are still taking up resources.

Nimbella Serverless Platform offers: Here's the code, use our CLI and run it.

If ten people have to run it, then make a bunch of containers so there is enough to run them all. And once they are done, get rid of the containers.

And the last question for this blog:

What are some good ways of learning Kubernetes?

YouTube videos are one of the best ways. There are many tutorials and videos available.

We recommend some channels and specific videos:
Google Cloud Tech Youtube channel:

What is Kubernetes?
How to run containers on Kubernetes TechWorld with Nana Youtube channel:
Kubernetes tutorial for beginners (4 hours crash course) IBM Cloud Youtube channel:
Kubernetes Explained Then you can use Kubernetes on Google and Amazon. They all have Kubernetes clusters. Use those clusters and get started instead of deploying your own Kubernetes cluster, which can be a lot of work.

Over to you: Kubernetes is hard - but worth the pain

In conclusion, we would like to share some highlights from the CNFC 2020 Survey and the perspective of Kubernetes to grow.

The survey cities:

The use of containers in production has increased to 92%, up from 84% last year, and up 300% from our first survey in 2016.
Kubernetes use in production has increased to 83%, up from 78% last year.
There has been a 50% increase in the use of all CNCF projects since last year’s survey.
Usage of cloud-native tools:
82% of respondents use CI/CD pipelines in production.
30% of respondents use serverless technologies in production.
27% of respondents use a service mesh in production, a 50% increase over last year.
55% of respondents use stateful applications in containers in production.

The trend and quick adoption of Kubernetes by enterprises is growing yearly and widely adopted by DevOps engineers, cloud architects, backend developers, DevOps management, full-stack developers, and other tech specialists.

If you’re looking for a scalable cloud solution then you should surely consider Kubernetes.

To ease the development of Kubernetes we offer Nimbella serverless platform that is available on prem, private, hybrid, and public cloud.

This interview has been taken by Yulia Aslamova.
Head of Marketing and User Acquisition at Nimbella

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

How to optimize Kubernetes costs with Nimbella

nimbella — Fri, 18 Jun 2021 03:18:47 +0000

Talking about costs is always a difficult topic because it is easy to focus on one aspect and neglect the others, and thus give a presentation that is not entirely in line with reality.

Here, I am presenting a realistic cost model applied in a cloud-native project and I will demonstrate how Nimbella works on Kubernetes and allows significant cost-saving compared to a "pure" development on Kubernetes.

Let's first clarify exactly what we mean by a "Cloud-Native" project.

Let's start by underlining that a "lift-and-shift" project that merely runs on Kubernetes, an application as a Virtual Machine without horizontal scalability properties, can’t be considered Cloud-Native.

What is Cloud-Native?

A cloud-native project has the following properties:

It scales horizontally by adding computing resources, the system adapts and uses the new resources
It distributes the load equally over the whole system and not just on a single component
It manages the "back-pressure". This means that it can manage situations in which requests increase faster than the system in its current state can handle.
It is structured in microservices, and can therefore be updated gradually in a granular and incremental way.

Essentially, it is necessary to create an architecture similar to the one that Nimbella provides, ready to use.

Workload of a typical cloud-native project with Kubernetes

Such a project has a complex architecture, that includes message queue management, data handling with NoSQL database, cache, and cloud storage, and it cannot be improvised. A Cloud Architect is therefore needed for its implementation.

If the project is a micro-services project, a pipeline must be created to build them continuously. Typically, for this purpose, it’s necessary to use Jenkins. Note that these pipelines need to be continuously updated and maintained. You, therefore, need a DevOps Engineer to handle this role.

A Microservice Application Development requires Kubernetes and Cloud expertise. Therefore, at least two Senior Developers are needed for development and two more Junior Developers.

How Nimbella reduces workloads

Let us now examine how much the same project developed with Nimbella would cost.

Nimbella offers a ready-to-use architecture for Native Cloud Development. It is a well-known architecture that applies best practices and patterns and is similar to those adopted by platforms like Facebook, Linkedin or Twitter. The architecture is proven, in production use and continuously updated by Nimbella. It, therefore, does not require a cloud architect to implement the platform.

Maintenance is greatly reduced as it is highly automated. A DevOps Engineer, part-time, is enough to maintain it.

No cloud skills are needed for application development, and there is no need to write Cloud Code but, instead, simply write Application Code only. One Senior Developer supported by two Junior Developers for development is therefore quite sufficient.

Finally, as Nimbella eliminates the DevOps pipeline, significantly reducing the amount of code to be written and streamlining deployment procedures, the development time is consequently reduced by at least 50%.

Everything is condensed into a spreadsheet here.

Author: Daniele Giuseppe di Pisa

Daniele began his career at the Technical Institute for Accounting in Milan after which he worked for 15 years in Italy for a Software House and Distributor of German BIM/CAD. This is where he learned to code. He moved on to working for WETO in Germany and then moved to China. Daniele now works with Nimbella in Sales.

Find him on LinkedIn.

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

Step by step guide on how to port from AWS to Nimbella

nimbella — Thu, 17 Jun 2021 08:29:19 +0000

AWS is the largest public cloud provider - but that doesn't make it easy to use!

It can be challenging to work with because:

AWS is confusing for developers without deep experience in low-level cloud technologies.
Businesses have to pay a hefty amount to get technical support from AWS.
AWS Pricing is fiendishly complex and difficult to predict. Also, it doesn't allow you to set a hard spending limit. 4.Need a credit card to sign-up.

Giuseppe Miragliotta, Backend Software Engineer at Xtream

AWS Lambda’s pay-per-use pricing model is ideal for sporadic usages because you’re never paying for over-provisioned infrastructure. On the other end, costs can sum up rapidly on highly intensive workloads since these kinds of resources are expensive. Nimbella can help you save costs by using LaaS or CaaS services that are cheaper than FaaS, providing a proven and actively maintained architecture.

Backed by Apache OpenWhisk, an open-source serverless solution, Nimbella comes with a high degree of portability. This means that the cost of moving to another cloud provider is greatly reduced and a multi-cloud strategy is also feasible, letting you choose the best products that suit your needs.

All these urge many users to look for the best AWS alternative which eventually gets them away from AWS Cloud lock-in.

In this article, we shall walk you through how Nimbella can fill up the space of AWS Lambda as an alternative and how you can port your functions to Nimbella.

Pros of Nimbella over AWS

The developers using the Nimbella platform only have to code the logic and Nimbella handles the rest including storage management, capacity provisioning, auto-scaling, monitoring, and logging.

Try Nimbella's platform with a real example

Let's create a new App and deploy it on Nimbella to get ourselves familiar with porting the functions from AWS-Lambda to Nimbella.

Please consider that we are going to create an invoice processing App with the below features

Approve/Reject invoices
Adding new invoices
Exporting invoices

It will use React.js for the front-end and Node.js for the Back-end. For data storage, we can use Amazon's dynamo DB in AWS-lambda and Nimbella's Redis in Nimbella Platform.

Basic architecture on Nimbella

Directory Structure on Nimbella:

Port your AWS Lambda functions to Nimbella

The following step-by-step guide will easily allow you to move your Lambda Functions to Nimbella.

Accounts creation and configuration Nimbella: Create a new Nimbella Account and it gets activated without providing any card details.
Install & Set-up CLI Let's install CLI to deploy and interact with the cloud platform through the terminal.

Nimbella's CLI can be installed by referring to this link for the respective Operating System.

To set up the CLI for Deployment and other activities we just need to log in to the CLI using the below command

nim auth login

Set-up Data Storage
Please consider that we are going to store our invoices as documents in the data storage.

Nimbella provides dedicated pre-integrated Redis key-value storage. We can directly use it as data storage without any configuration. We can do CRUD operation with our DB via CLI using the traditional Redis command as below.

nim kv set <keyName> <keyvalue>

Create Your API for Invoice Processor

Create a directory named "packages" which wraps the back-end code.
Create a new directory that represents the app name inside packages.
Create a new directory name that represents the API endpoint. Please note that in Nimbella each directory name represents API endpoints. Hence, create the directory how you want to name the API endpoints.
Initiate a node js project with nim init -y
Install nim-sdk package to access Nimbella's Redis.

Once done, we can read our invoice data from Nimbella's Redis with the below code.

Create a project.yml file and specify our directory structure (http end-points) of our function as below.

Our Serverless function can be deployed by running the below-given command in Nim-CLI.

nim project deploy <directory containing our proj>

Once deployed, we can get the API URL for the deployed function using the below command.

nim action get action <functionName>

Now, our API is ready to serve the requests seamlessly.

Deployed API URL (Nimbella):

https://boltnew2-doofwstmxcq-apigcp.nimbella.io/api/invoice/getdata

Front-End

Let's create a React App by running the below command.

npx create-react-app <appName>

Once React App is created, we can implement the below features in the UI for the Invoice Processor in the usual React way as below.

Consume the API created in the previous step to render the invoices

Approve/Reject Invoices
Export Approved/Rejected/Pending invoices (using jsPdf)
Add new invoices.
Invoice Processor

Our React App can be hosted on Nimbella by following simple steps:

Create a build.sh file and specify the commands to create a build from React Ap
Create a .include file and specify the file to be included for deployment
Configure project.yml for hosting our front-end as below.
React App hosts on Nimbella 3-1

Directory of our Invoice Processor having the React App (front-end) & Serverless function (Back-end) looks as below.

We can deploy our Invoice Processor App by running the below command.

nim project deploy <projectDirectory>

Once completed the host URL of Invoice Processor can be found in CLI as below.

https://boltnew2-doofwstmxcq-apigcp.nimbella.io/

GitHub Source: https://github.com/boltathi24/nimbella_redis_react_invoice_processor

In Brief: Porting Aws-lambda to Nimbella:

Wrap the AWS-Lambda's functions inside the directory named "packages".
Wrap the front-end code inside the directory named "web".
Create a project.yml file and specify the configuration of the serverless function.
Deploy it to Nimbella using Nimbella's deploy command.

Benefits of Nimbella over AWS-lambda limitations

Nimbella provides a better developer experience by letting developers focus and invest time on App logic by removing architectural complexity.
Nimbella supports multi-cloud deployment. Serverless Apps built on Nimbella can be deployed into your choice of cloud provider at any time.
Nimbella provides integrated monitoring and logging to conveniently access logs and statistics from the terminal. Logging is more centralized and the output of the function won't be feeling disjointed anymore since Logging can be accessed with Nimbella's CLI instead of heading to CloudWatch in AWS.
Our smart CLI builds the artifacts to be deployed dynamically from the project's configuration file, unlike AWS Lambda where we zip the dependencies for deployment.
Vendor lock-in is avoided with our multi-cloud deployment feature.
Most of the popular programming languages are supported by the Nimbella Cloud (e.g., JavaScript, TypeScript, PHP, Python, Java, Go, or Swift, etc.)
Nimbella lets developers feel themselves developing the end-to-end application by providing a way to deploy front-end (UI) and back-end (API) as a single deployment.
Nimbella cloud platform is built on an open-source, Apache OpenWhisk. Hence it provides more data security and access control.
No card details are required. Start with a generous free tier and grow with us.
Nimbella offers dedicated secure domain, certificate management, CDN, and much more with ease.
There is no development effort when you switch between cloud providers.
The learning curve with Nimbella is very simple. You won't be amused with the 'n' number of services like AWS.
Native support for state with in-memory high-performance data storage(Redis).

Conclusions

Nimbella is a modern developer-friendly Serverless platform that empowers you to build and run serverless applications in the simplest way. When you look out for alternatives to AWS Lambda, Nimbella suits perfectly and you can port your functions to Nimbella without much effort.

Please feel free to check out the latest Forrester Report on why Nimbella has been named as a Strong Performer among multiple players in the serverless space. Nimbella is a rising new generation serverless platform that could be considered as a great alternative to AWS and other cloud providers.

Author details: Athithan Raj P

Follow him on Twitter: @raj_athithan

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

How to build and improve your serverless APIs

nimbella — Thu, 17 Jun 2021 08:26:24 +0000

Current state of the serverless market

Modern software revolves around APIs, making it fundamental for developers to have high-quality and robust tools to create meaningful APIs. Serverless computing provides the speed, reliability, control, and development flexibility they need to rapidly scale up their software application - making it an indispensable tool when building complex workflows and stateful APIs.

In fact, the demand for serverless computing is so high that the market is estimated to surpass 21 billion worldwide by 2025. Enterprises leveraging serverless platforms, such as Nimbella, will reap the financial and operational benefits as it promises to reduce operational overhead and costs to manage the infrastructure, quicker deployment to market, and an increase in developer productivity.

Our latest conference about serverless

In our last conference we wanted to provide an outlet that will help developers in the space learn more about this emerging technology and how they can leverage it on their own. As such, we hosted a conference called “Serverless & APIs,” where we gathered industry experts in the space to educate and discuss with developers how to build and improve serverless APIs.

The speakers

The speakers invited included some real experts in the serverless industry like:

Rodric Rabbah, Nimbella's very own CTO and co-founder

Rodric talked about “Unleashing the Potential of Stateful Serverless Computing”. Rodric was a Principal Researcher and the technical lead for serverless computing at IBM. He is the creator and the lead contributor to Apache OpenWhisk, an advanced and production-ready serverless computing platform. He was awarded an IBM Outstanding Innovation Award and an IBM Outstanding Accomplishment Award for his leadership and impact on IBM Cloud Functions.

Allen Helton, Tyler Technologies' Software Engineering Manager

Who went over “Power Tuning Your Serverless API For Happy Customers”. Allen demonstrated a history of working in the computer software industry. Skilled in Javascript, NoSQL, RESTful API services, and AWS cloud development. Strong engineering professional with a Bachelor of Science (B.S.) focused in Software Engineering from The University of Texas at Dallas.

Keith Casey, Okta's API Problem Solver

Keith covered “API Security: When Failure Looks Like Success”. Keith currently serves on the Product Team at Okta working on Identity and Authentication APIs. Pro great things. In his spare time, he helps build and support the Austin tech community, and blogs at CaseySoftware.com. He is also a co-author of “A Practical Approach to API Design” from Leanpub.

William Lyon, Developer Relations Engineer at Neo4j

who discussed “Low Code Serverless GraphQL APIs in A Cloud First World”. William is a software engineer at Neo4j, the open-source graph database, working on database integrations and extensions as part of the Neo4j Labs team. He is also the author of the Manning book "Fullstack GraphQL".

Why is serverless the future of developing?

Here are a few key takeaways from the event on unleashing the potential of stateful serverless computing, and how to align and fine tune APIs with serverless technologies:

It's a great way to build software because you don't have to worry about servers, networking, or load balancing. The beauty of a serverless API is how many options you have as destinations. Simple API transforms can go straight to the database without executing a serverless function. They scale vertically automatically based on traffic and can handle bursts without issue if your site gets hit with a bunch of traffic at one time.
You can identify issues and what needs power tuning with out-of-the-box analytics about individual endpoints that come from cloud providers. Analytics that tell you which endpoints get hit most often, which ones are slow, and which ones fail more often than others. Businesses can take these metrics and use them to identify problem areas in their application. If an endpoint is hit 60% more than all the others but runs about 30% slower, that's a prime example of an area that needs developer attention.
You can make significant performance improvements to your serverless APIs in seconds. You can allocate more memory and processing power by simply changing a number or moving a slider. You can remove unnecessary serverless functions by going straight to the database. There are a lot of easy tricks you can do that make powerful optimizations.
You can build highly scalable applications instantly. A primary obstacle holding enterprises back is that while many cloud-native serverless platforms are built only for stateless apps, enterprises use a combination of different applications using features like object and file storage, data tools, and more that, without unsustainable DevOps overhead, restrict the potential of any serverless posture. With stateful serverless support, these applications work seamlessly inside the serverless environment, unleashing the full potential of serverless development to deploy across the full network using the full range of business applications an organization needs.
It frees developers from the burden of infrastructure maintenance so they can focus on coding application logic. When developers have to duplicate their efforts two and three times to deploy the same application to separate public clouds, it's a waste of time. By freeing them from this enforced redundancy, they will be able to deliver greater efficiency while working in a manner that's more conducive to creative iteration.

With all of the benefits serverless computing offers it's no surprise that the market is expected to grow rapidly; and with the Nimbella Postman Plugin, you can take your APIs into a serverless world seamlessly. The plug-in allows developers to extend the functionality of Postman by adding commands to support an API-first development strategy. This approach allows for rapid prototyping, supports a services ecosystem, and enables automated deployment, testing, and continuous delivery pipelines that are extremely important for modern applications. For Installation and User Guide click here.

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

How to build and improve your serverless APIs

nimbella — Thu, 17 Jun 2021 08:20:18 +0000

Current state of the serverless market

Our latest conference about serverless

The speakers

The speakers invited included some real experts in the serverless industry like:

Rodric Rabbah, Nimbella's very own CTO and co-founder

Allen Helton, Tyler Technologies' Software Engineering Manager

Keith Casey, Okta's API Problem Solver

William Lyon, Developer Relations Engineer at Neo4j

Why is serverless the future of developing?

Here are a few key takeaways from the event on unleashing the potential of stateful serverless computing, and how to align and fine tune APIs with serverless technologies:

It's a great way to build software because you don't have to worry about servers, networking, or load balancing. The beauty of a serverless API is how many options you have as destinations. Simple API transforms can go straight to the database without executing a serverless function. They scale vertically automatically based on traffic and can handle bursts without issue if your site gets hit with a bunch of traffic at one time.
You can identify issues and what needs power tuning with out-of-the-box analytics about individual endpoints that come from cloud providers. Analytics that tell you which endpoints get hit most often, which ones are slow, and which ones fail more often than others. Businesses can take these metrics and use them to identify problem areas in their application. If an endpoint is hit 60% more than all the others but runs about 30% slower, that's a prime example of an area that needs developer attention.
You can make significant performance improvements to your serverless APIs in seconds. You can allocate more memory and processing power by simply changing a number or moving a slider. You can remove unnecessary serverless functions by going straight to the database. There are a lot of easy tricks you can do that make powerful optimizations.
You can build highly scalable applications instantly. A primary obstacle holding enterprises back is that while many cloud-native serverless platforms are built only for stateless apps, enterprises use a combination of different applications using features like object and file storage, data tools, and more that, without unsustainable DevOps overhead, restrict the potential of any serverless posture. With stateful serverless support, these applications work seamlessly inside the serverless environment, unleashing the full potential of serverless development to deploy across the full network using the full range of business applications an organization needs.
It frees developers from the burden of infrastructure maintenance so they can focus on coding application logic. When developers have to duplicate their efforts two and three times to deploy the same application to separate public clouds, it's a waste of time. By freeing them from this enforced redundancy, they will be able to deliver greater efficiency while working in a manner that's more conducive to creative iteration.

This blog was initially published on Nimbella. Keep an eye out for this space and follow us on Twitter for the latest updates.

Simplifying Kubernetes For Developers

nimbella — Wed, 19 May 2021 12:11:34 +0000

Introduction to Kubernetes Architecture

For the past several years, Kubernetes has been gaining traction among the developers including enterprise developers. Gartner predicts that Container Management will grow to $944 Million by 2024 and Kubernetes is expected to drive the growth. Forrester points out a vibrant Kubernetes landscape driven by large-scale adoption of Kubernetes.

Kubernetes: solid growth for the coming years

The Cloud Native Survey 2020 put out by Cloud Native Compute Foundation points out to 300% increase in container adoption since 2016 and an 83% increase of Kubernetes adoption in production. The success of Kubernetes was driven by the developer adoption of container technologies and an operational need for standardization. While Kubernetes offers many benefits, it also offers many challenges which organizations have to overcome to realize optimal ROI.

In this blog post, we will talk about how the Nimbella platform helps organizations overcome some of the challenges and help improve developer agility, leading to much better ROI for organizations.

Benefits & Shortcomings of Kubernetes

Even though container adoption was kickstarted by the developer community, Kubernetes gained more traction among the IT operations and DevOps, mainly driven by the declarative approach to Operations and standardization. Today Kubernetes is used by developers, DevOps, SRE, and IT Operations teams in many large organizations.

The strengths of Kubernetes

Some of the benefits of using Kubernetes are:

Increased agility for developers as they can easily package their code and dependencies into containers and push it across the DevOps pipeline
Ability to run both legacy applications (through lift and shift) and modern applications under similar environments
Standardization of Operations, simplifying the cost of IT operations
Better resource usage as more applications can be packed into the compute units by using containers

YAML Complexity impacts Developer Productivity

While Kubernetes provides these advantages to both developers and IT operations, it adds significant challenge for developers due to what is known as YAML complexity. As we have pointed out earlier, Kubernetes uses a declarative approach to orchestrating and managing the containers. In order to do it successfully, Kubernetes requires a configuration file in the YAML format.

A developer wanting to push their application to a Kubernetes cluster will have to define everything about their application, deployment, services, the definition of how states are handled, network, security bindings, etc. using multiple YAML files (as shown in the image below).

Kubernetes and complex applications: a difficult relationship

While it may not be complex for simple applications, the YAML configuration files become very complex for complex applications and most enterprise applications. In fact, the Cloud Native Survey 2020 by CNCF points out complexity as the major challenge faced by the users of Kubernetes. This YAML complexity dramatically impacts developer productivity and agility, leading to suboptimal benefits that defeat the very use of Kubernetes by modern enterprises.

Lack of Programming Model

Another big challenge with Kubernetes is the lack of an inbuilt programming model that will make it easy for developers to deploy their applications. While Kubernetes operators do a good job in providing a resource model to manage the underlying clusters and some application dependencies, it doesn’t provide developers to easily handle the application dependencies from the programming language of their choice. They will need to rely on third-party libraries to handle these needs, impacting developer productivity and adding unnecessary DevOps overhead.

Abstracting Away YAML Complexity from Kubernetes With Nimbella

However, there’s a way of taking advantage of the strengths of Kubernetes without the hassle of the YAML and other limitations. This is called Nimbella.

Nimbella helps Developers focus on business logic

If Cloud Computing is about abstracting the infrastructure complexities and making it easy for users, then adding operational overhead for developers and adding friction makes little sense. It is important to provide an abstraction that gives a simple interface for developers so that they focus on the business logic rather than the configuration files needed to deploy applications in a containerized environment.

Nimbella, a Serverless platform built on top of Kubernetes, tries to solve this challenge and make it frictionless for developers to deploy their applications in a Kubernetes environment. With the Nimbella platform, developers need not worry about the DevOps overhead and focus on innovating at the speed of business. Nimbella provides the developer abstraction that allows developers to easily deploy serverless API by focusing on the code than the operational elements of the underlying container infrastructure or YAML complexity.

With this abstraction, developer productivity is significantly enhanced and allows them to deploy their applications friction-free, at the speed of business.

Nimbella makes cloud-native development seamless

Nimbella also tackles the lack of programming language support from Kubernetes by providing necessary integrations that allow developers to focus on the application code and not worry about managing the application dependencies, further adding to the YAML complexity.

Nimbella removes the friction point for developers using Kubernetes by giving a seamless Serverless experience. For example, Nimbella’s Netlify addon provides Jamstack developers an easy serverless experience, removing friction and improving productivity.

Whether you are deploying modern applications that are stateless or stateful enterprise applications, Nimbella takes the pain out of managing the dependencies and the YAML complexity associated with deploying applications that use these dependencies including the state. Enterprises should remove any friction for their developers including any DevOps overhead like the YAML complexity problem of Kubernetes platforms.

The blog post is authored by Rishidot Research

About Rishidot Research:

Rishidot Research is the next-gen research and analysis firm focused on helping modern enterprise decision-makers understand and navigate cloud-native and artificial intelligence landscape.

This blog was initially published on Nimbella. Keep an out for this space and follow us on Twitter for latest updates.

What is Nimbella and what does it offer?

nimbella — Wed, 05 May 2021 07:52:58 +0000

What is Nimbella and why it was featured in the Forrester report along with the public cloud providers?

There was Twitter buzz regarding the latest annual Forrester report on the most significant FaaS vendors in 2021 where different cloud influencers were asking - what is Nimbella?

Forrester Wave™: Function-As-A-Service Platforms, Q1 2021 report covers the nine most significant serverless platform providers. Eight out of the nine are the largest public cloud vendors and there is only one startup that made it into the category of the Strong Performers - Nimbella!

So let us answer the most intriguing questions -

What is Nimbella?
Why was Nimbella named the strong performer?
How to start with Nimbella?

Well, let us share more about what is Nimbella, our vision and key features of the Serverless Platform.

What is Nimbella?

Nimbella is a silicon valley startup that makes serverless development frictionless and portable. Nimbella’s serverless platform unifies the programming experience and provides the necessary abstractions to enable the developers to code once and run on cloud-of-their-choice. It is available as a hosted service and as a full-stack solution on any public or private Kubernetes environment.

Now let me share some key features of the Nimbella Serverless Platform:

We are the only multi-cloud platform → No Vendor lock-in.
We are based on open standards - Our co-founder and CTO, Rodric Rabbah was the co-creator of Apache OpenWhisk).
We simplify the developer experience of developing on Kubernetes infrastructure (public or private)

Find more about the Nimbella Serverless Platform: Download The Technical Whitepaper

Why was Nimbella named the strong performer?

The report provides a 40-criterion evaluation of function-as-a-service (FaaS) platforms and identified the nine most significant ones and scored the vendors’ performance across three categories: current offering, strategy, and market presence.

The Forrester report cites:

“Nimbella fully embraces hybrid cloud with a FaaS-anywhere approach. Like IBM Cloud Functions, Nimbella is based on the open-source Apache OpenWhisk project. Nimbella adds a simple, fast developer onboarding process to a runtime that developers can use in a pure FaaS model, as an installable function platform on other public clouds, or even on-premises. Nimbella delivers this FaaS-anywhere approach with robust container support, broad support for programming languages, and configurable settings for maximum function duration. The result: a FaaS solution that well suits long-running stateful functions.“

Nimbella uses a cloud-native software stack that delivers a runtime environment for functions and containerized applications. It is available as a hosted, managed service and as a full-stack solution on any public or private Kubernetes environment to fully support an enterprise's multi-cloud strategy.

Nimbella Serverless Platform includes these components:

Developer Tools - CLI & browser-based tool
Serverless Compute - functions and containers engine
Serverless Storage - integrated key-value store and object store
System Services - Logging, monitoring, tracing and more
Management Tools - admin CLI and dashboard to manage underlying infrastructure

Find out more about Nimbella, an enterprise-grade Serverless Platform by downloading the whitepaper on “The State of Serverless in the Enterprise” by Rishidot Research - > Download The Business Whitepaper

How to start with Nimbella?

Nimbella is available as Nimbella Enterprise and Nimbella Cloud.

To sign up for Nimbella Cloud simply use your GitHub login (no credit-card required) here.
Contact Nimbella at sales@nimbella.com to use Nimbella Enterprise which is installable on the cloud-of-your-choice or your private infrastructure.
There is also a no sign-in (anonymous) option where you can create, run and share up to ten serverless functions in multiple languages.

I hope I have answered most of your questions, if not, feel free directly to reach out to me agarwal.anshu@nimbella.com.

This blog was initially published on Nimbella. Keep an out for this space and follow us on Twitter for latest updates.

Results and Feedback of FaaS Wars - May the FaaS Be with You!

nimbella — Sat, 10 Apr 2021 06:57:03 +0000

After a wildly successful FaaS Wars Season 1 that witnessed some awesome robots and extensive global participation, we could not resist hosting another Season right after. If you missed your chance in the previous competition, buckle up because we have another challenging season lined up ahead.

Prepare yourself for FaaS Wars 2 right away and participate between April 26 - July 26. This time too, you can expect a lot of cool robots, intense battles, and exciting cash prizes.

Hint: It’s going to be a team competition this time. Start bringing your army together!

Now, let’s give you a brief about FaaS Wars Season 1 and how it panned out so you can prepare for Season 2.

Season 1 of FaaS Wars turned out to be truly global. We had participation from countries across the world where maximum participation came from:

India
Italy
Russia
Poland
United States of America
Sri Lanka
Canada

The purpose of the competition was to initiate developers to learn Serverless while also having fun. We saw more than 1,800 FaaS Warriors and more than 500 awesome robots fight to win the title of the #ServerlessJedi Episode 1.There were 3 episodes in this season and with each passing season, the battles keep getting more intense.

Developers actively made use of the tutorial videos, written guides, and blog posts that we shared with them throughout the event to improve their chances of winning and quickly learn more about serverless computing.

By the end of the season, we had 2 winners, one of whom won two episodes.

What was FaaSWars?

For those of you who aren’t familiar with FaaS Wars, let us help you with some information.

FaaS Wars was a three-month global robot coding competition organized by Nimbella and members of the Apache OpenWhisk community. It was the first season of this competition and was live from Jan 2021 - March 2021 and had three episodes.

The prize for the competition was a cash prize of up to $1,400, which was divided between the three stages. The winner of the first episode was awarded $200, the second episode winner won $400 and the winner of the third round received $800 in cash prizes.

Partners that helped Nimbella during FaaS Wars

Nimbella partnered with several big names like Incubate IND, Java Mentor, Apptimia, J/S Bangalore meet up group, This Dot Media, Bangalore CNFC meet up group, Girlscript.Tech and Anstack.io.

What was FaaS Wars about?

Participants had to code their robots, use functions to guide them on the battlefield, shoot lasers at opponent robots, and defeat them on the battlefield.

When a battle was fought, the winner of one round progressed to battle with the winner of another battle and the same continued until the final battle.

Who were the winners?

The final battle or the season finale was won by Michele Curci from Italy, who was also the winner of our episode 1. Michele was awarded $800 for the season finale and $200 for his victory in episode 1. The name of the robot that Michele used to fight the battles was Cortex2. Michele even supported other players by writing an elaborate blog on how he coded his robot that helped him win.

The feedback about Nimbella Serverless Platform by Michele Curci, Big Data Backend Developer Presso Almaviva Digitaltec

Our second winner for episode 2 was Tyler Zerr from the United States who fought the battles with his robot named TooncesV4. We admire the spirit and enthusiasm with which Tyler participated in the competition.

The feedback about Nimbella serverless platform by Tyler Zerr, Systems Analyst SaskTel

If you missed this season, we ask you not to be disheartened as we will soon be launching FaaS Wars Season 2, which will be more challenging and even more fun.

May the FaaS be with you!

Author:
Mihika Pal is an independent marketer working currently with Nimbella and a content writer. She began her career as a hotelier and then moved onto marketing. She is extremely passionate about writing and likes to work independently with brands on their marketing campaigns. You can find her profile on Upwork as one of the Top rated talents in her field.

This article was initially published on Nimbella's blog. To read more such articles, keep an eye out for this space, follow us on Twitter and visit our website.

28 Serverless Gurus and experts One Must Follow in 2021

nimbella — Thu, 01 Apr 2021 13:21:00 +0000

Serverless is a constantly evolving space with something new being discovered every day. Being a relatively newer field, developers and enterprises are constantly learning how Serverless can be made easy and the adoption of Serverless technology can be made faster.

For the benefit of such learners, we have put together a list of 30 Serverless Experts that any Serverless enthusiast must look out for in 2021.

Every expert has been carefully evaluated based on their expertise, their contributions to Serverless, their GitHub stars/karma points on Hacker News and other platforms, and what one can learn from them.

There is no particular order that we have followed and every person mentioned in the list is equally important and valuable.

Let’s get started with the list.

Yan Cui

Yan Cui is one of the leading names in the Serverless space and is currently working as the principal consultant at THEBURNINGMONK, Dev advocate at Lumigo.

Yan’s expertise and what you can learn from him:

His focus is to help organizations around the world accelerate product and feature development by adopting Serverless technologies and helping them avoid costly mistakes.

Where you can find his work:

You can find all of his posts around Serverless on his Medium blog and also on his theburningmonk website. Yan Cui aims at helping people understand and adopt Serverless through his podcasts and also through workshops and masterclasses on his page.

You can follow him on Twitter and LinkedIn to find a lot of good information about Serverless technology.
Find him here: Website, Medium, Twitter, LinkedIn.

Kelsey Hightower

Kelsey Hightower is a Staff Developer Advocate at Google, co-chair of KubeCon, the largest Kubernetes conference, and an avid open-source technologist.

Kelsey’s expertise and what you can learn from him:

He has assumed several technology roles during his career and is one of the leaders in the Kubernetes space.

Kelsey extensively talks on topics related to Serverless, Kubernetes, open-source, and others and he aims at building simple tools that make life easier.

Where you can find his work:

Currently, you will often find him talking about an application that will help people come out of debt using common sense. Kelsey has a very minimalistic approach and maintains that on his Twitter feed as well.
Find him here: Medium, Twitter, LinkedIn.

Rodric Rabbah

Rodric Rabbah is the co-founder and CTO of Nimbella. He is also a creator and a lead technical contributor to Apache OpenWhisk.

Rodric’s expertise and what you can learn from him:

He was a Principal Researcher at IBM, where he created Apache OpenWhisk.

Where you can find his work:

Rodric takes the lead in several events on Serverless and extensively writes several articles on Serverless cloud computing, and APIs on his blog.

His efforts are driven towards helping enterprises and developers move ahead in their journey towards Serverless adoption.
Find him here: Website, Medium, LinkedIn, Twitter.

Jeremy Daly

Jeremy has very recently assumed the position of the GM of Serverless Cloud at Serverless Inc. Jeremy's contribution to Serverless has been massive.

Jeremy’s expertise and what you can learn from him:

Amongst the many topics that Jeremy is an expert in, Serverless comes at the top of his list.

Where you can find his work:

He has spoken in many conferences, written numerous blogs, created several open-source projects, wrote the newsletter Off-by-none, and even wrote a Serverless musical!

His focus is on helping others learn and adopt Serverless along with programming and product management.

Find him here: Website, Medium, Twitter, LinkedIn.

Slobodan Stojanović

Slobodan is the CTO of Vacation Tracker and Cloud Horizon, and also the organizer of the JSBelgrade Meetup group.

Slobodan’s expertise and what you can learn from him:

He is an AWS Serverless Hero, Claudia.js core team member, and co-author of Serverless Applications with Node.js book.

Where you can find his work:

Slobodan writes many articles on Serverless and Node. You can find most of his articles on his website.

You can also learn from his several talks that he has delivered on Serverless, Serverless architecture, and others, all of which are present on his personal website.
Find him here: Website, Medium, Twitter, LinkedIn.

Tom McLaughlin

Tom McLaughlin is the founder of SeverlessOps and a leading Serverless Advocate in the DevOps community.

Tom’s expertise and what you can learn from him:

His company is a consulting firm that provides Serverless infrastructure training and advisory services for DevOps transformations.

It was his curiosity of what would happen if servers were gone that got him digging deeper.

Where you can find his work:

Tom has authored the book Serverless DevOps and also writes some great articles on his blog, ServerlessOps. He also delivers many talks on Serverless infrastructure.

He focuses on the operational aspects of Serverless and you can learn the challenges associated with it, and how the responsibilities of Operations Engineers are changing.
Find him here: Medium, Twitter, LinkedIn.

Sam Kroonenberg

Sam Kroonenberg and his brother Ryan Kroonenburg, co-founded A Cloud Guru, a startup that has changed the technical training paradigm.

Sam’s expertise and what you can learn from him:

Their online platform has trained students across the world in AWS.

Where you can find his work:

He actively speaks and writes about Serverless, cloud computing. You can find his work, videos, and contributions to the Serverless community on the official ACG blog.

Find him here: Medium, Twitter, LinkedIn.

Ryan Kroonenburg

Ryan Kroonenburg is the brother of Sam Kroonenburg, who together founded A Cloud Guru, the platform that trains beginners as well as professionals to become experts in the cloud.

Ryan’s expertise and what you can learn from him:

He knows the world of the cloud inside out and is confident that his courses are like no other.

ACG has truly shifted the trend in technical training.

Where you can find his work:

You can find his courses on Udemy. Ryan is also the co-founder of Serverless Conf and is extremely passionate about Serverless.

You can find his blogs, videos, and talks on Serverless, cloud computing, and AWS across the internet.

Find him here: Medium, Twitter, LinkedIn.

Danilo Poccia

Danilo Poccia is the Chief Evangelist (EMEA) at AWSCloud and specializes in Serverless, IoT, AI/ML analytics among others.

Danilo’s expertise and what you can learn from him:

Danilo works with companies and startups of all sizes, works on Serverless architecture, technical programming, and business innovation.

Where you can find his work:

You can read his book AWS Lambda in Action, a book about event-driven Serverless Applications. He also writes and speaks on Serverless and you can find all his work on his website.

Danilo helps bring ideas to life and you can learn how to do exactly that using Serverless from him.
Find him here: Website, Medium, Twitter, LinkedIn.

Paul Johnston

Paul’s expertise and what you can learn from him:

Paul Johnston had previously co-founded the ServerlessDays and then moved to providing Interim CTO services, Advisory, Due Diligence, Technology, and Cloud Consulting Services, and cutting edge Cloud and Serverless strategic consulting and development services to companies around the world.

Where you can find his work:

He actively contributes to the Serverless community by publishing some great content on his Medium Blog.

You can also find many of his talks on YouTube where he extensively talks and educates people about Serverless.

Find him here: Medium, Twitter, LinkedIn.

Ajay Nair

Ajay Nair is the General Manager of the Lamda Experience at AWS.

Ajay’s expertise and what you can learn from him:

He has delivered several talks on Serverless, Serverless architecture, Serverless considerations amongst others.

Where you can find his work:

He has also co-authored the book Serverless Architectures on AWS and writes extensively on his tweets about Serverless and keeps offering updates and opinions on the same.

Find him here: Twitter, LinkedIn.

Marcia Villalba

Marcia has been in the software industry for over 10 years now and currently works as a full-stack developer at Rovio.

Marcia’s expertise and what you can learn from her:

She also owns her consultancy firm Unicorn.codes that help companies migrate to Serverless by educating them or providing hands-on help.

Where you can find her work:

Marcia has a YouTube channel by the name FooBar where she focuses on teaching AWS Serverless technologies through fun videos.

You can also find lots of courses by her on Serverless in English and Spanish.

Along with the many titles, she has won, she is also a Serverless Champion and a co-organizer of the Finland AWS User Group.

Find her here: Website, YouTube, Medium, Twitter, LinkedIn.

Ben Kehoe

Ben Kehoe is a Cloud Robotics Research Scientist at iRobots making Serverless Roombas.

Ben’s expertise and what you can learn from him:

While he works on using the internet to enable robots to do better things, he focuses on developing businesses through Serverless applications.

Where you can find his work:

He avidly writes and speaks about Serverless and discusses its applications, the future and the present, and how it could benefit businesses.

His Twitter feed is also quite interesting with lots of information on Serverless along with his blog on Medium.

Find him here: Medium, Twitter, LinkedIn.

Charity Majors

Charity Majors is currently the CEO and Co-founder of Honeycomb but previously she served as an operations and database engineer for several years.

Charity’s expertise and what you can learn from her:

She is enthusiastic about several topics all related to computers and speaks on several topics including Serverless, CloudOps, AWS, debugging databases, and many more.

Where you can find her work:

You can find her articles on her blog where she has a separate page where she talks about Serverless and all things related.

You can also often find interesting pieces written by her about Serverless on her tweets.

Find him here: Website, Twitter, LinkedIn.

Julian Wood

Julian Wood currently works as the Serverless Developer Advocate and his motto is to make the world fall in love with Serverless.

Julian’s expertise and what you can learn from him:

You can find his Twitter feed loaded with tweets and reshares about interesting things about Serverless, AWS Lamda functions, and Cloud.

Julian also receives a lot of praises for the presentations and talks he delivers and he speaks a lot about Serverless.

Where you can find his work:

You can find many of his articles on his blog. Julian is also one of the lead contributors on Serverless Land.

Developers can learn how to transform the way they build their applications using Serverless technologies from him.

Find him here: Website, Twitter, LinkedIn.

Adam Johnson

Adam Johnson is the former co-founder of IOpipe which was acquired by New Relic and specialized in monitoring and observability for AWS Lamba Serverless applications.

He now is the Principal Product Manager at New Relic Serverless where he is helping developers build modern applications on Serverless.

Adam’s expertise and what you can learn from him:

Adam and his IOpipe co-founder Erica Windisch are highly experienced in the field of Serverless and they help enterprises gain granular views into their Serverless applications to troubleshoot applications.

Where you can find his work:

You must look out for Adam's tweets as they are very relevant, informative and some of the best out there.

Find him here: Website, Medium, Twitter, LinkedIn.

Erica Windisch

Erica Windisch and Adam Johnson together formed IOpipe which was then taken over by New Relic during which Erica along with Adam joined the New Relic team and is now the Principal Engineer at New Relic.

Erica’s expertise and what you can learn from her:

Erica has been helping organizations maximize the benefits of Serverless applications, speed up debugging processes, and building tools to help companies adopt Serverless.

Since 2002, Erica has been innovating cloud computing technologies.

Where you can find her work:

She actively speaks at Serverless events and also maintains her blog on Medium where she talks about how their technologies could help enterprises as well as developers.

Find her here: Medium, Twitter, LinkedIn.

Srushith R

Srushith is the Head of Engineering at Konfhub Technologies.

Srushith’s expertise and what you can learn from him:

He is passionate about building Serverless applications and sharing experiences at various events across the globe and believes that Serverless is the future of software development and the way applications will be built moving forward.

Where you can find his work:

He has started Serverless Saturdays, a monthly webinar focusing on everything Serverless aimed at helping developers kickstart their Serverless journey.

He has also recently founded the Tirupati AWS User Group and also started the first Serverless-focused meetup group in Bangalore, India. Developers can follow him to get started with their journey towards Serverless.

Find him here: Medium, Twitter, LinkedIn.

Allen Helton

Allen Helton is a Software Engineering Manager at Tyler Technologies with a demonstrated history of working in the computer software industry.

Allen’s expertise and what you can learn from him:

His focus lies in proper API development, Serverless technology, cloud development, and AWS.

He also works closely with the companies Postman and The Open API Initiative.

Where you can find his work:

You can follow his blog on Medium where he writes extensively about Serverless, Cloud, best practices, and updates.

Allen also often speaks on Serverless on different platforms and helps the community on platforms like Dev.to by answering queries and loves sharing his knowledge on his blog Ready, Set, Cloud!

Find him here: Dev.to, Medium, Twitter, LinkedIn.

Rob Allen

Rob Allen is a software consultant and developer with many years of experience in a variety of interesting languages.

Rob’s expertise and what you can learn from him:

He's particularly interested in APIs and the ecosystem around them and contributes to Apache OpenWhisk, rst2pdf & Slim Framework along with other open-source projects.

Where you can find his work:

Rob is a published author and based in the UK where he runs Nineteen Feet Limited, focussing on API development, training, and consultancy.

In his spare time, Rob blogs at akrabat.com and can often be seen with a camera in his hand.

Find him here: Website, Medium, Twitter, LinkedIn.

Pavan Belagatti

Pavan Belagatti works as the Growth Manager & DevOps Advocate at Shippable and for the DevOps and Community Engagement at JFrog.

Pavan’s expertise and what you can learn from him:

He is very enthusiastic about DevOps and is also a tech storyteller who writes avidly on his Medium Blog. He is a Google certified digital marketing professional.

Where you can find his work:

He has written over 100 articles on the topic of DevOps alone, also writes about growth hacking for startups, personal branding, and motivation.

Pavan aims to bridge the gap between marketing and tech.

He contributes extensively on platforms worldwide, some of them being Linux Foundation, DZone, The Next Web, Influencive, Thrive Global, Tech in Asia, Entrepreneur Magazine, Computer Weekly. All his work on Kubernetes and DevOps on his blog are in the form of very interesting stories.

Find him here: Medium, Twitter, LinkedIn.

Keith Casey

Keith Casey currently serves on the Product Team at Okta working on Identity and Authentication APIs.

Keith’s expertise and what you can learn from him:

Previously, he served as an early Developer Evangelist at Twilio and before that worked on the Ultimate Geek Question at the Library of Congress.

His underlying goal is to get good technology into the hands of good people to do great things.

Where you can find his work:

In his spare time, he helps build and support the Austin tech community, and blogs at CaseySoftware.com. He is also a co-author of “A Practical Approach to API Design” from Leanpub.
Find me here: Twitter, LinkedIn.

Michele Sciabarra

Michele is currently the CEO of a consultancy firm focused on Kubernetes and Serverless, sciabarra.com. He is also the Area Manager for Nimbella Europe where he focuses on building the core products.

Michele’s expertise and what you can learn from him:

Michele has authored the book O'Reilly in which he demonstrates how to build a Serverless application using classical design patterns and the programming language.

He is one of the most influential and knowledgeable figures in the Serverless space and publishes articles and training guides extensively on several platforms.

Where you can find his work:

Michele has a huge following on LinkedIn where he shares great insights and updates about Serverless, deep learning, and other technology updates. You can learn everything about Serverless by following his guides, reading his articles, shares and by following his work.

Find him here: Website, Medium, Twitter, LinkedIn.

Benjamin Smith

Ben is also a senior developer advocate for Serverless Applications at Amazon Web Services based in London, UK.

Benjamin’s expertise and what you can learn from him:

Previously, he has worked extensively in Workflow automation and web development which shows that he is passionate about Serverless, open-source technology, and automation.

You can learn from him how Serverless technologies can be made more accessible for PHP developers.

Where you can find his work:

A lot of Benjamin's tweets on Twitter talk about Serverless, the latest developments, and tips to help the community with Serverless technologies.

He is also one of the lead contributors on Serverless Land and delivers talks and numerous great articles on Serverless, PHP, and adoption of Serverless technologies.

Find him here: Twitter, LinkedIn.

James Thomas

James is currently an independent Software Consultant and has worked with IBM previously for 13 years. He specializes in Cloud Application Development and Serverless.

Jame’s expertise and what you can learn from him:

His last role at IBM was that of a Lead Developer Advocate for Serverless at IBM Cloud. James is an open-source committer and PMC member on Apache OpenWhisk.

He is the co-founder of the Serverless Days London Conference series after which he created the Serverless Days movement.

Where you can find his work:

James widely posts on his blogs on several Serverless topics and also speaks at conferences worldwide. You can find a lot of information on Serverless and the latest developments through the conference videos all on Youtube.

Find him here: Website, Medium, Twitter.

Rowan Udell

Rowan Udell is a Cloud Practise Director at Versent and is enthusiastic about Serverless, DevOps, software development, CI/CD, and AWS.

Rowan’s expertise and what you can learn from him:

Rowan also launched a course by the name The Serverless Framework: Build a Chatbot on the A Cloud Guru Platform.

Where you can find his work:

He has co-authored the book The AWS Administration Cookbook and also spoken on several topics about Serverless.

You can find all his talks and videos on his blog and also catch his podcast on Cloud and Serverless under podcasts. His articles are some of the best informational ones out there on Serverless.

Find him here: Website, Twitter, LinkedIn.

Forrest Brazzeal

Forrest Brazzeal is currently a senior manager at A Cloud Guru, he spent years designing applications for the cloud at Infor and Trek10 and led Serverless projects.

Forrest’s expertise and what you can learn from him:

He hosted the Think FaaS Serverless podcast at Trek10. Forrest is also a cartoonist and has created the comic FaaS and Furious.

Where you can find his work:

He is also one of the original Amazon Serverless Heroes and currently interviews big names for the Serverless Heroes Series at A Cloud Guru.

He also speaks and writes extensively on cloud computing and you can find his work on his blog as well as Trek 10 and ACG websites. You can learn a lot from him about FaaS and cloud computing.

Find him here: Website, Medium, Twitter, LinkedIn.

Chris Munns

Chris Munns is the Lead Developer Advocate for Serverless Applications at Amazon Web Services.

Chris’ expertise and what you can learn from him:

Chris writes some of the best articles on topics related to Serverless.

Where you can find his work:

You can also find his articles on the Serverless Land blog where is one of the lead contributors.

He is known to speak at many conferences and meetups in the Serverless Community in many different communities. He is also interested in and talks about other topics including DevOps and Cloud.

Find him here: Website,Medium, Twitter, LinkedIn.

That’s about it. Follow these Serverless Experts and grow your understanding of Serverless easily.

Author:

Mihika Pal is an independent marketer working currently with Nimbella and a content writer. She began her career as a hotelier and then moved onto marketing. She is extremely passionate about writing and likes to work independently with brands on their marketing campaigns. You can find her profile on Upwork as one of the Top rated talents in her field.

This blog was initially published on Nimbella's blog. To read more such articles, keep an eye out for this space, follow us on Twitter and visit our website.

CI/CD pipeline with GitHub Actions

nimbella — Thu, 11 Mar 2021 07:00:08 +0000

In this blog, we are going to learn step-by-step how to set up a Serverless CI/CD pipeline on Nimbella using GitHub Actions.

What is CI/CD?

Continuous Integration refers to the practice of creating a build as a new code. Comment end is committed to running automated tests against that build to verify that everything works correctly.

Github-ci-cd: https://docs.github.com/en/actions/guides/about-continuous-integration

Continuous Delivery is the practice of automatically deploying code to production.

CI/CD Flow

CI/CD pipeline is one of the best practices for DevOps teams to implement, for delivering code changes more frequently and reliably.

CI/CD with GitHub Actions on Nimbella

GitHub Actions let you build, test, and deploy your code right from GitHub.

Nimbella is a modern serverless platform in which CI/CD can be implemented with modern CI/CD Pipeline GitHub actions that result in saving developers time and effort.

CI/CD on Nimbella using GitHub Actions

We can implement CI/CD pipeline on Nimbella using GitHub Actions with the below steps.

Build the App.
Write an Automated Test for the App.
Set-up CI/CD using GitHub Action.

1. Build the App

Please consider that we are going to build a real-time URL shortener app. We can create our shortener app with Node.js as backend and React.js as frontend which can be deployed into Nimbella Serverless Platform as mentioned in the article below.
How to deploy Node.js functions on Nimbella.

We may set up a free mongo DB cluster as Database for our app by referring to Get Started with Atlas.

Please note that to run this application, you'll need to have Git, Node.js, and NPM already installed.

Let’s clone the code into our local directory using the below command.

git clone https://github.com/bolt-hub/github-ci-cd-nimbella-shortener.git

The directory having the code for our shortener app looks as below:

Project Directory of Shortener App

2. Write Automated Test for the App

Automated testing enables continuous testing and ensures that bugs get found early and are fixed before the end-users experience any breaks.
Please consider that we are going to write our automated test with the popular Jest Framework. Let’s execute the below commands from the root of the project directory to install npm packages for the Jest framework.

npm init -y

npm install --save-dev jest mongoose nanoid dotenv

Create Jest configuration files i.e, jest.config.js & jest.setup.js, and change the test script defined in package.json to run the Jest binary. Now when we run the test script, this Jest command is going to run.

After updating the Jest test run command in package.json, it looks as below.

Package.json after updating test Run command

Create a test file that validates test cases for the app using Jest Framework as below.

const { Mongoose } = require("mongoose");
const app = require("./index");
const mongoose = require('mongoose')
describe("Validates Response when URL Shortener is Requested", () => {
test("Validates Response URL shortener for Positive flow", async () => {
var requestBody = {
actual_url:
"https://nimbella.com/blog/how-to-deploy-node-js-functions-on-nimbella",
};
var appResponse = await app.main(requestBody);

expect(appResponse.body.success).toBe(true);
expect(appResponse.statusCode).toBe(200);
});
});

afterAll(async done => {
// Closing the DB connection allows Jest to exit successfully.
mongoose.connection.close();
done();
});

After writing test validation for our serverless action, the directory will look as below:

Directory Structure after Adding Automated Tests

3. Set-up CI/CD using GitHub Action

Create a new Repository in GitHub. Navigate to the Actions tab on this repository and set up a basic workflow.

GitHub Actions Link on Repository
Let's clone our new repo which has default GitHub actions and move the code for Shortener into this.

We can get a non-expiring token to deploy our app into Nimbella by running the below command on nim CLI.

nim auth export --non-expiring

Copy the token generated from the above command and add it as a GitHub secret. Also, add the environment variables of serverless action as GitHub secrets as below.

Configuring GitHub Secrets

The final step of configuring the Specification CI/CD pipeline on Nimbella using GitHub Action is to modify the YAML file under ./GitHub/workflows as per our deployment specifications as below.

GitHub Actions YAML Specification

Once the above configuration is specified, whenever code changes are pushed to the repository, GitHub Action will trigger the configured CI/CD Pipeline/workflow to achieve CI/CD.

Let’s test the CI/CD workflow by pushing the code to the repository. After pushing the code changes, if we check-out the “Actions” tab of the repository, it will look as below which indicates that CI/CD workflow has been triggered.

GitHub Actions Triggers Workflow

Successful Job Run through GitHub Actions

In Brief and to Sum-up:

Build your code as per Nimbella’s serverless framework structure
Create Automated Test to validate serverless action
Create a GitHub Repo and navigate to the Actions tab of the Repo and set up a sample GitHub workflow.
Configure Nimbella’s Auth token & environment variables under GitHub Secrets of the same Repo.
Modify the GitHub action’s YAML file to test deploy the app using nim CLI.
Push/Pull (as mentioned in the YAML file) the code to trigger the workflow.

GitHub Source: https://github.com/bolt-hub/github-ci-cd-nimbella-shortener.git

Please feel free to experiment with CI/CD workflow on Nimbella using the above example with few steps given below.
1.Create a Nimbella Account and install nim CLI.
2.Create a new Github Repo and configure the environment variables & Nimbella’s Auth token as GitHub secrets on the same Repo.
3.Clone the above code from Git and push it to your newly created Repo. Once the workflow run has been completed, you may check-out your live URL shortener as below.

Deployment Log info

This article was originally published on Nimbella's blog. If you would like to read more such articles, visit our website to find the blog.

Also, follow us on Twitter @nimbella to never miss an update from us again.