Serverless on stigterhq.nl

Simply Stateful Serverless

Thu, 28 Oct 2021 00:00:00 +0000

One of the things I love about serverless is that I never have to be bothered with managing servers, it’s just using a service like Lambda, Cloud Run, etc and my code is running. If I want to use a database I can rely on services like DynamoDB or CosmosDB. While I think that is absolutely great, it feels like serverless is only for stateless processes. I think serverless needs a bold and stateful vision so that we can build any type of application (stateful and stateless) without ever managing servers. In this talk, I’ll touch on why statefulness matters and how stateful serverless makes patterns like Event Sourcing and CQRS available to anyone.

Why (stateful) serverless matters for server admins

Tue, 21 Sep 2021 00:00:00 +0000

In the session I went over why serverless is important to our industry, why server admins (which I then rephrased to SREs) are so important to our serverless success, and why stateless isn’t the answer for everything. Technology wise I’ll be “all over the map” talking about things like Knative and the VMware Event Broker Appliance, AWS Lambda, Akka Serverless

Lightbend's Akka Serverless enables stateful app development without a database - SiliconANGLE

Thu, 10 Jun 2021 00:00:00 +0000

Leon Stigter, senior product manager for serverless at Lightbend, explained the core problem to SiliconANGLE: developers generally think of serverless as a “stateless solution,” meaning every time an application needs to do something, it has to connect to a database first. For a single service that’s manageable, but at scale, things like connection pooling get painful fast.

How To Secure Akka Serverless Apps With Auth0

Tue, 08 Jun 2021 00:00:00 +0000

As Auth0 says on their website “Identity is the front door of every user interaction”. When you’re building serverless applications, that becomes even more important since you often have multiple apps that all need to be secured. In this post I’ll walk you through how to wire up Auth0 with Akka Serverless.

How To Set Up Continuous Integration and Delivery With Github Actions and Akka Serverless

Tue, 01 Jun 2021 00:00:00 +0000

CI/CD is one of those things that pays for itself almost immediately. In serverless especially, where the whole point is to focus on code and let the platform handle the rest, automating your deployment pipeline is a no-brainer. It lets developers focus on code and lets the business ship quality software faster. So how does that work with Akka Serverless?

Thinking Stateful Serverless @ Micro.Sphere.IT

Wed, 09 Dec 2020 00:00:00 +0000

As developers, we all want to be more productive. Serverless helps you do just that, by letting you focus on the business logic while shifting operations somewhere else. As more companies discover this emerging technology, we also discover drawbacks like state management. In this session, I focused on what serverless is, how it helps developers, what potential drawbacks exist, and how we can add state management into serverless.

Test-driving Event-Driven Apps on Kubernetes

Thu, 15 Oct 2020 00:00:00 +0000

As developers, we all want to be more productive. Knative, a Kubernetes-based platform to deploy and manage modern serverless workloads, helps to do just that. The idea behind Knative is to abstract away the complexity of building apps on top of Kubernetes as much as possible, and Tekton is a powerful and flexible open-source CI/CD tool. How can you bring those two together on your local machine to try a few things out or even develop your apps? During this talk, we looked at setting up a KinD cluster, bootstrapping Knative and Tekton, and deploying an app!

Deploying your first app on the Kubernetes based Knative platform

Thu, 13 Aug 2020 00:00:00 +0000

As developers, we all want to be more productive. Knative, a Kubernetes based platform to deploy and manage modern serverless works, helps to do just that. The idea behind Knative is to abstract away the complexity of building apps on top of Kubernetes as much as possible. How can you get Knative running on your local machine to try a few things out or even develop your apps? In this session, we ’ll look at setting up a Kubernetes cluster, installing Knative, and building an app.

Data Driven Decisions in DevOps @ MyDevSecOps

Thu, 02 Jul 2020 00:00:00 +0000

With everything going on in DevOps, I think we can safely say that building pipelines is the way to deploy your applications to production. But knowing what you deploy to production and whether it is actually okay needs more data, like security checks, performance checks, and budget checks. We’ve come up with a process for that, which we call Continuous Verification “A process of querying external systems and using information from the response to make decisions to improve the development and deployment process.” In this session, we’ll look at extending an existing CI/CD pipeline with checks for security, performance, and cost to make a decision on whether we want to deploy our app or not.

Automated DevOps for the Serverless Fitness Shop

Thu, 25 Jun 2020 00:00:00 +0000

In a nutshell, Continuous Verification is about putting as many automated checks as possible into your CI/CD pipelines. These checks call out to external systems to validate performance, security, and cost — without asking your engineers to do that manually. The same systems that decide whether a deployment goes to production can also help engineers understand where the bottlenecks are. More checks in the pipeline means fewer manual tasks, less overhead, and better decisions about what actually ships. And yeah, maybe a bit more time at the beach.

How to set up a local Knative environment with KinD and without DNS headaches

Wed, 03 Jun 2020 00:00:00 +0000

Knative builds on Kubernetes to abstract away complexity for developers, and enables them to focus on delivering value to their business. The complex (and sometimes boring) parts of building apps to run on Kubernetes are managed by Knative. In this post, we will focus on setting up a lightweight environment to help you to develop modern apps faster using Knative.

Continuous Verification In A Serverless World @ Open Source Community Day

Thu, 30 Apr 2020 00:00:00 +0000

At VMware we define Continuous Verification as:

“A process of querying external systems and using information from the response to make decisions to improve the development and deployment process.”

At #OSSDay, I got a chance to not only talk about what that means for serverless apps and how you can build it into your existing pipelines using tools like GitLab, CloudHealth, Wavefront and Gotling.

Building a Serverless Fitness Shop - Observability

Wed, 15 Apr 2020 00:00:00 +0000

If you’ve read the blog posts on CloudJourney.io before, you’ve likely come across the term “Continuous Verification”. If not, no worries. There’s a solid article from Dan Illson and Bill Shetti on The New Stack that explains it in detail. The short version: Continuous Verification means putting as many automated checks as possible into your CI/CD pipelines. More checks, fewer manual tasks, more data to smooth out and improve your development and deployment process.

So far we covered the tools and technologies, Continuous Integration, and Infrastructure as Code aspects of the ACME Serverless Fitness Shop. This post is about observability.

Building a Serverless Fitness Shop - Infrastructure as Code

Wed, 08 Apr 2020 00:00:00 +0000

In part one we covered the tools and technologies and in part two we covered the Continuous Integration aspect of the ACME Serverless Fitness Shop. This post is about Infrastructure as Code.

Building a Serverless Fitness Shop - Continuous Anything

Wed, 01 Apr 2020 00:00:00 +0000

Building a Serverless Fitness Shop - Tools and Tech

Mon, 23 Mar 2020 00:00:00 +0000

If you’ve read the blog posts on CloudJourney.io before, you’ve likely come across the term “Continuous Verification”. If you haven’t, no worries. There’s a solid article from Dan Illson and Bill Shetti on The New Stack that explains it in detail. The short version: Continuous Verification is “A process of querying external system(s) and using information from the response to make decision(s) to improve the development and deployment process.”

Tracking Distributed Errors In Serverless Apps

Mon, 09 Mar 2020 00:00:00 +0000

Microservices give us as developers an incredible amount of freedom. We can choose our language and we can decide where and when to deploy our service. One of the biggest challenges with microservices, though, is figuring out how things go wrong. With microservices, we can build large, distributed applications, but that also means finding what goes wrong is challenging. It’s even harder to trace errors when you use a platform like AWS Lambda.

Continuous Verification In A Serverless World @ Serverless Nashville

Thu, 27 Feb 2020 00:00:00 +0000

At VMware we define Continuous Verification as:

“A process of querying external systems and using information from the response to make decisions to improve the development and deployment process.”

At Serverless Nashville, I got a chance to not only talk about what that means for serverless apps but also how we use serverless in some of the business units at VMware.

Hybrid Security - From On-Prem to Serverless

Mon, 24 Feb 2020 00:00:00 +0000

DevOps, as a practice to build and deliver software, has been around for over a decade. What about adding security to that, though? After all, security is one of the cornerstones of today’s information technology. As it turns out, one of the first mentions of adding security was a Gartner blog post in 2012. Neil MacDonald wrote,

“DevOps must evolve to a new vision of DevOpsSec that balances the need for speed and agility of enterprise IT capabilities (…)”.

How To Create AWS Lambda Functions Using Pulumi And Golang

Tue, 28 Jan 2020 00:00:00 +0000

I’ve used Pulumi to do a bunch of things so far: creating subnets in a VPC, building EKS clusters, and DynamoDB tables. The one thing I hadn’t tried yet was deploying Lambda functions, so that’s what this post covers.

Trusting your ingredients - What's in your function anyway?

Fri, 24 Jan 2020 00:00:00 +0000

As a developer, I’ve built apps and wrote code. As a cheesecake connoisseur, I’ve tried many different kinds of cheesecake. After I got to talk to some of the bakers, I realized that building apps and baking cheesecake have a lot in common. It all starts with knowing and trusting your ingredients.

According to Tidelift, over 90 percent of applications contain some open source packages. Developers choose open source because they believe it’s better, more flexible, and more extendible. A lot of developers also fear how well packages are maintained and how security vulnerabilities are identified and solved.

How To Make Your AWS EKS Cluster Use Fargate Using Pulumi And Golang

Thu, 16 Jan 2020 00:00:00 +0000

At re:Invent, AWS introduced the ability to run EKS pods on AWS Fargate, and Fargate is cheaper than hosting Kubernetes yourself. In the last post I created an EKS cluster, so this one adds a Fargate profile to it.

Cost Matters! The Serverless Edition

Mon, 09 Dec 2019 00:00:00 +0000

As a trend cloud vendors tend to use the word serverless quite loosely. While serverless comes in a lot of shapes and sizes and as long as the characteristics fit within the four categories from my last blog, it is a serverless service. To make sure that we’re all on the same page, I’ll use the following definition for serverless:

“Serverless is a development model where developers focus on a single unit of work and can deploy to a platform that automatically scales, without developer intervention.”

In this blog post, we’ll look at how that model works on AWS Fargate, which allows you to run containers without having to manage servers or clusters.

Serverless - From Microservice to Functions

Mon, 09 Dec 2019 00:00:00 +0000

Using serverless requires us to change our mindset on how we build apps and requires us to unlearn things we learned building apps in the past. At AWS re:Invent I got a chance to do a VMware Code session and talk about how we took part of our ACME Fitness Shop and transformed it into serverless functions with AWS Lambda.

Serverless - The Wrath of Containers

Mon, 09 Dec 2019 00:00:00 +0000

Containers were this awesome technology that ushered in the Cloud era and with a lot of new FaaS tools coming along, companies are wondering if they should jump the container ship altogether. As it turns out, containers definitely have value in Serverless. In this session we will take an existing containerized app and move it into AWS Fargate, look at the cost of running it, and how we can monitor it.

Why Serverless Architectures Matter

Mon, 04 Nov 2019 00:00:00 +0000

There are many predictions from market analyst firms on the size of the global serverless architecture market and how fast it will grow. The numbers range from $18B](https://industrynewsreports.us/8860/serverless-architecture-market-set-for-rapid-growth-to-reach-around-18-04-billion-globally-by-2024-2/) to [$21.99B in the next few years with the compound annual growth rate (CAGR) in the double digits. But is serverless only a fancy name for products like AWS Lambda and Azure Functions?

Event-Driven Architectures - Putting Jazz Into Apps

Fri, 11 Oct 2019 00:00:00 +0000

The CTO of a company I have worked for used to say that services should be loosely coupled but tightly integrated. I didn’t realize until a lot later how true that statement is as you’re building out microservices. How those microservices communicate with each other has also changed quite a bit. More often than not, they send messages using asynchronous protocols. As an industry, we decided that this new way of building apps should be called “Event-Driven Architecture (EDA).”

How to send CloudFormation events to Wavefront using AWS Lambda

Fri, 20 Sep 2019 00:00:00 +0000

Imagine this, it’s 5pm on a Friday afternoon and while you really want to go enjoy the weekend, you also need to deploy a new version of your app to production. Using AWS CloudFormation (CF), you add a new instance to your fleet of EC2 instances to run your app.

How to Get Webhooks Into Your System Using Solace PubSub+ Cloud

Wed, 05 Jun 2019 00:00:00 +0000

Sometimes you need to get data from cloud-based systems into an environment that doesn’t expose APIs or ports to the outside world. Webhooks help, but you still need something that accepts them and gets them across your firewall. That’s exactly where Solace PubSub+ Cloud comes in. I built a small webhook forwarder app that receives data from Solace and sends it onward without any of my systems being exposed to the internet.

How To Use Distroless Containers & OpenFaaS To Minimize Attack Vectors

Mon, 07 Jan 2019 00:00:00 +0000

I’ve been playing with OpenFaas ever since I learned about Minikube a few years ago, so when one of my colleagues mentioned Google’s Distroless project I obviously needed to see if my Go projects could work using those images too.

How To Build A Serverless Contactform With Zeit

Wed, 02 Jan 2019 00:00:00 +0000

Serverless platforms have been getting a lot of attention. AWS announced a ton of things at their annual user conference, Google announced support for Go in private beta and serverless containers in private alpha, and even Gitlab announced some form of serverless support. With all the big players, it’s easy to overlook the smaller ones — but they’re often the most interesting.

Deploying Flogo Apps to Lambda with the Serverless Framework (Part 2)

Thu, 16 Aug 2018 00:00:00 +0000

I can hear you think “Part 2?! So there actually is a part 1?” 😱 The answer to that is, yes, there most definitely is a part 1 (but you can safely ignore that 😅). In that part I went over deploying Flogo apps built with the Flogo Web UI using the Serverless Framework. Now, with the Go API that we added to Flogo, you can mix triggers and activities from Flogo (and the community) with your regular Go code and deploy using the Serverless Framework.

Efficiently Build And Deploy Event-driven Functions to Kubernetes & AWS Lambda

Fri, 03 Aug 2018 00:00:00 +0000

Building multi-platform event-driven microservices and functions can get complicated fast. In this short webinar hosted by DZone, I cover how to use Project Flogo to build event-driven microservices and functions that target both Kubernetes and AWS Lambda — without losing your mind in the process.

How To Build a Slack Bot Powered By Project Flogo

Fri, 15 Jun 2018 00:00:00 +0000

This post walks through building a Slack bot that responds to a /cat slash command with cat facts. The bot is built with Project Flogo, runs on AWS Lambda, and is exposed through API Gateway. The whole thing takes about 15 minutes to set up.

Adopting Serverless Computing with TIBCO & AWS

Tue, 03 Apr 2018 00:00:00 +0000

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

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

Serverless and Flogo - A Perfect Match

Sat, 24 Mar 2018 00:00:00 +0000

I get to work with serverless microservices on a daily basis, those are services I use myself and ones I help our customers build to take advantage of the benefits that serverless brings you. With many services needing to be deployed and continuous updates, I found myself doing the same thing over and over. It is that specific task that frustrates me most; it simply wasn’t as seamless as I thought it could be.

In this article, I’ll walk you through how I cut the development time and make deployments easily repeatable like a walk in the park — thanks to the combination of the Serverless Framework and a tool called Project Flogo.

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

Fri, 01 Dec 2017 00:00:00 +0000

This year I wasn’t able to attend re:Invent, but I did want to do something nice in between the live streams and specifically around Serverless compute and AWS Lambda.

Lambda lets you run code without provisioning or managing servers. You pay only for the compute time you consume — there is no charge when your code is not running. With Lambda, you can run code for virtually any type of application or backend service — all with zero administration. Just upload your code and Lambda takes care of everything required to run and scale your code with high availability.