From null to applications on Kubernetes

For many, Kubernetes is a big hurdle to get over. In actuality, it's just a platform for running applications with many built-in features, and is no less complicated than running applications on any other platform. There is a lot that happens up to the point where your code hits the node, and even after that one has to be weary that defaults usually aren't the best approach.

In this session, we start with an empty git repository, build a shiny new application, squeeze it into a container which we then ship to a Kubernetes cluster, and in the end expose it to the world. Think of this as a development cycle speed run.

This talk aims to go through the process of developing an application for Kubernetes. We start by writing our application, we run tests and package it into a container, and then go through all the caveats of running our application with Kubernetes. This is mostly a hands-on presentation, with few slides.

The app is developed in a programming language that fits the conference, or Golang by default.

Building APIs and backend services that run PowerShell

When PowerShell first started out, it was primarily aimed against automating system administration, where the users created scripts that they ran locally on their machine or a server. To make this happen by itself and on a timer, we could set up a scheduled task, and that was enough for most of us.

These days, with the rise of Platform Engineering, we want to take our domain specific knowledge and make it available as a product or service. In the old days this would have been difficult without investing in proprietary systems, but as many PaaS solutions supports either PowerShell natively or containers, we can now create full-fledge backend services that utilize PowerShell for the business logic.

In this talk, I want to show a couple of examples how you can help your PowerShell to scripts to take a new life in a cloud-native world.

Create GitHub Actions with PowerShell

GitHub, like most developer platforms, got everything you need for your projects. It's got a place to store your code, tools for project handling and maybe even more important a full fledged CI/CD solution. With GitHub Actions we can create templates of code to be reused in several workflows, like creating PowerShell modules that is used in several scripts. We can use actions that others create, but sometimes the best solution is to create your own to get the result you need.

In this session I want to go show some of the possibilities you have with GitHub Actions, and go through the process of creating a GitHub Action built with PowerShell.

Building an Internal Developer Platform on Azure

As the operations team strive towards DevOps, some major shifts in responsibility are happening. We no longer want to have dedicated teams for operations, but give that responsibility to those who develop the product or service. But to ensure that the cloud infrastructure is set up in a secure and efficient manner, we need to help bridge the gap between developers and cloud provider. For this talk, I want to explain what an Internal Developer Platform is, and how we can build one using cloud native tools available on Microsoft Azure.

Getting started with Terraform and Azure

Infrastructure-as-Code, if done right, is one of the best ways to gain more control over your assets in the cloud. Terraform is one of the most popular tools of the trade, and can help you deploy efficiently and securely to any cloud provider, including private clouds. In this talk, we will discuss how to get started using Terraform, and how to use it to provision resources in Azure. We will learn how Terraform work, how to write configuration files that are reusable, and see how we can utilize CI/CD tools to automate the process.

This talk has been given, in one form or another, to several companies, and to many IT professionals. Audience don't need to know Terraform at all to participate, but the talk itself is highly technical.

The Platform Engineering Journey

People in tech usually don't struggle with the technical implementation, but they often struggle with technical decisions and strategy. Over the years, I have observed trends come and go, but there have been a couple that truly make a difference. One of the more recent trends is that of Platform Engineering, which is the accumulation of what we have learned over the years in IT-operations, combining DevOps with a product mindset to make sure that developers can focus on creating business value instead of having to deal with infrastructure and cloud architecture decisions.

In this talk, I would like to explore some of the common pitfalls, talk about my experiences going from traditional sysadmin to platform engineer, and give you all a great start on your platform engineering journey.

The arrival of Platform Engineering

In our industry, one of the few constants is that we are in constant change, and just like our software, we can see incremental changes to how we structure teams and organizations. After the term DevOps came about, we have seen several variants of the team that helps the organization adopt these new processes, usually referenced to as a platform team.

But as the term Platform Engineering takes hold, some proclaims that DevOps is a thing of the past. What it actually means is that we have seen the benefits of DevOps, and distilled into a domain for modern operations. In this talk, I would like to discuss if we have we finally arrived in the DevOps promised lands, or if we still have more iterations to go through before we can fully and truly embrace DevOps.

Creating flexible Terraform modules

A Terraform child module is great to gather code that will deploy a specific service based on your needs, for instance Azure Kubernetes Service (AKS) or virtual machines. At the bare minimum, AKS can be a deployment of one node pool but at the other end it might be several pools, identity management, choices about versioning, and much more. A virtual machine can have several data disks, be backup enabled, have anywhere from one to several network interfaces, and there is even a unique resource if it's a Windows machine or Linux. Things get complicated pretty quickly.

This talk is based on battle hardened modules, which helps you adhere to best practices and standards, while is flexible enough to break patterns when you need it. For this session we will not be looking at slides, but actual code. We will deep dive into some of the functions and expressions that Terraform has to offer, so there should be something for everyone in this talk.

Target audience is Terraform professionals or individuals with prior knowledge of Terraform. This is a presentation with no slides, everything is shown through actual code. Preferred session length is 30 minutes, 45 with questions.

GitOps: The past, present and future

Operations through Git is not new but now we the technology to realise what we always wanted. The GitOps pattern has matured over the years, from the initial definition to the major adoption by the community, and the arrival of Kubernetes and the controller/operator pattern has made it possible to adopt GitOps in practice.

Although we have come far, there is still more work to be done. This is why the OpenGitOps project was created in the Cloud Native Computing Foundation, where we hope to define what it means to use GitOps and spread awareness.

This talk is aimed to explain the concept of GitOps, why we need it and how it can be implemented. It is based on the principles defined by the OpenGitOps project and is a vendor and platform neutral look at the operational model.

Preferred as a 30/45 minute session, and the target audience is everyone from developers, to operational engineers, to decision makers.

Workshop - GitOps with Flux

In the cloud native era, GitOps have become one of the preferred methods of handling application deployment. When developers have created their applications, we don’t want to write imperative and bespoke pipelines for deployment, it should just work.

This workshop was created to help you to go from no knowledge of GitOps, to running a multi-tenant and efficient deployment procedure, with automatic and self-healing application deployments.

You need to have some knowledge about Kubernetes concepts, like how to deploy resources and write manifests, and foundational knowledge of Git for this workshop.

In this workshop, the attendees get to experience setting up multiple environments from a mono-repository, based on Kustomize and GitOps best practices. We will go through multi-tenant deployments, automation of container tags, and progressive delivery with Flagger.

This workshop was first held during KCD Oslo 2024, and received good feedback.