Thorsten Hans

Book Progress & Illustrations

Wed, 16 Sep 2026 05:32:25 +0200

Here we are, another week later. Again, a few days have passed since I’ve published my last update on the book and shared some thoughts on inclusive pricing.

Since I’ve published that update, I’ve made some substantial progress. Overall, I consider the first six chapters of the book to be pretty close to “done” now.

A pretty big refactoring of the sample application made me rewrite a massive chunk of the chapters that guide the reader through implementing the sample application and writing tests against it. IIRC, I closed the lid of my laptop Sunday evening around 11:30pm with a slight sense of satisfaction.

Book Progress & Thoughts on Inclusive Pricing

Tue, 08 Sep 2026 09:26:00 +0200

Hey everyone,

I wanted to drop a quick update on Building Serverless Applications with WebAssembly & Spin.

Honestly, I’m really happy with how the book is shaping up right now. I’ve been sinking a lot of late-evening and early-morning hours into refining chapters, restructuring sections, and proofreading the code examples to ensure it’s as hands-on and practical as possible. It’s a labor of love, but seeing it come together makes every late night worth it.

Now

Mon, 07 Sep 2026 02:13:50 +0000

Updated on 2026-09-08.

I’ve got the basics covered on my /about page, so head there if you’re searching for more. This page is about what’s currently on my mind and my immediate plans.

Location

Saarland, Germany

Work

I work at Akamai as a Sr. Developer Advocate.

Projects

Spin and SpinKube

Life

Currently in a body recomposition phase, which means I try to hit the gym at least three times a week while keeping calorie intake pretty strict.

I’m Writing a Book on WebAssembly and Spin

Sat, 15 Aug 2026 14:05:00 +0200

Hey friends 👋🏼,

If you’ve been following my activities over the recent years, you know I can’t stop talking about the third wave of cloud computing. Server-side WebAssembly is completely changing the game for cold-start latency and container bloat.

Today, I’m thrilled to announce I’m turning those talks and architectural patterns into a practical, hands-on guide:

Building Serverless Applications With WebAssembly & Spin

Sign up and Stay in the Loop

Instead of theoretical fluff, I structure the book in a way that readers will build a complete, multi-component serverless application from the ground up using Rust and Spin.

Component Composition with Spin 4.0

Fri, 14 Aug 2026 19:15:00 +0200

Thanks to the WebAssembly Component Model we can stitch together multiple WebAssembly Components. Reusing Wasm Components boost developer velocity dramatically while language barriers vanish. In this hands-on article, I’ll explain how you can compose Wasm Components using Spin 4.0.

What You Need To Follow Along

I’ll try to keep things as simple as possible. That’s why we’ll implement both components using Rust, resulting in the following - short - list of requirements:

Azure DevOps Extensions for Spin, Fermyon Wasm Functions and Fermyon Cloud

Thu, 16 Oct 2025 10:15:00 +0200

Do you want to build and deploy your Spin applications from within Azure DevOps pipelines? No matter if you want to target Fermyon Wasm Functions or Fermyon Cloud, the extensions I published to the Visual Studio Marketplace are here to help.

Earlier today I published three distinct extensions for Azure DevOps allowing you to do all-the-things Spin, Fermyon Cloud and Fermyon Wasm Functions straight from within your Azure DevOps pipelines.

Although everything could be accomplished using good old bash scripts as part of your pipeline, dedicated “steps” are way more convenient and integrate seamlessly with core concepts of Azure DevOps pipelines like referencing variables, secrets, or leveraging variables produced by those steps to lay out control flow (conditions).

What I’ve Been Up To

Wed, 15 Oct 2025 10:15:00 +0200

Although this blog became a bit quite recently, I wrote a bunch of articles over on our corporate blog. I thought it’s worth sharing a comprehensive list of the posts I wrote:

OpenAPI Documentation for Spin Apps with Rust In this guide, I’ll show you how to generate OpenAPI Specification (OAS) documentation directly from Spin apps written in Rust. You’ll learn how this improves API discoverability, speeds up onboarding, and unlocks tooling like SDK generation and testing.

Uses

Sun, 24 Aug 2025 02:13:50 +0000

I tinker and update my setup very often. However, I try to keep this list as updated as possible. If you’ve further questions, send me a tweet @ThorstenHans.

Hardware

2026 MacBook Pro 14" (M5 Max | 64 GB | 2 TB) as daily driver
2024 iPad Air 11" in Light Purple
iPhone 15 Pro Max in graphite (256 GB)
Garmin Fenix 8
AirPods Pro 3 + AirPods Max
ZSA Voyager in black
Logitech MX Master 3
2x LG 4k 27" Screens

Software

This blog is built with Hugo
I use Zed and neovim as my main editors
Preferred themes:
- Osaka Jade
- catppuccin mocha
- SynthWave 84
- Rose Pine
When it comes to fonts, I either use Monaspace Krypton or Dank Mono
I’m a terminal guy using Ghostty with tmux and oh-my-zsh
My prompt is build with Starship
I take notes in Notion and manage my tasks using Apple Reminders
Team Apple Music 🎶

Accessories

Apple HomePod Mini
2x Sonos One SL
Shure MV6
Evergoods CTB 26
DJI Osmo Pocket III

WebAssembly and Containers with Docker Desktop - Hello World & Beyond

Wed, 28 Feb 2024 15:27:55 +0100

On top of being the runtime for containers, Docker Desktop is also able to run WebAssembly (Wasm) workloads. In this article, we’ll explore how one can run both containers and Wasm workloads together to build distributed architectures using the best of both worlds.

Beta Feature: Wasm workloads in Docker Desktop is currently marked as a beta feature.

What we are going to build

Discovering new topics, or learning emerging technologies often goes best when looking at a practical example. For the sake of this article, we’ll start with a simple Hello, World. From there, we’ll move on and orchestrate a simple three-tier application consisting of two containers (frontend and postgres) and a Wasm module (api).

Wasm ahead - Joining Fermyon

Mon, 08 Jan 2024 12:05:52 +0100

Hey everyone 👋🏼

A couple of weeks ago, I wrote about my farewell to Thinktecture. After sharing that news back in December, many readers, followers, and friends reached out to ask what my next chapter would be. It was really hard not to share the news right away, but I had to wait for the right time.

I am more than excited to finally unveil that I will join Fermyon as a Cloud Advocate starting February 1st, 2024. 🎉

A Farewell to Thinktecture

Wed, 20 Dec 2023 12:23:44 +0100

Hello everyone 👋🏼,

I wanna share some personal news with you today. After an incredible journey spanning almost nine years, I’ve decided to bid farewell to Thinktecture AG. My last day with the company will be at the end of January 2024.

Reflecting on my time here, I am grateful for the experiences, challenges, and growth opportunities that have shaped me personally and professionally. Since joining in June 2015 as a Developer/Consultant, I’ve had the privilege of working alongside great people, helping developers navigate the complexities of emerging technologies.

A comprehensive guide on authoring plugins for Fermyon Spin

Fri, 25 Aug 2023 10:05:15 +0200

Did you know that you can extend the spin CLI with custom plugins that integrate seamlessly and feel like functionality provided by Fermyon itself?

No? No problem!

In this article, we will explore how I build the check-for-update plugin - a simple Spin plugin that allows you to check if your local installation of the spin CLI is outdated. On top of building the actual Spin Plugin, we’ll also go through the process of testing and distributing the check-for-update plugin. Finally we’ll wrap up this article by adding the custom Spin Plugin to the Spin Up Hub, to ensure users can discover it.

Weekly Rust Trivia: How to use pattern matching

Thu, 03 Aug 2023 13:00:00 +0200

Weekly Rust Trivia is a problem-oriented series of articles that assist developers while learning Rust. Every article solves simple, everyday development tasks using the Rust standard library or leveraging popular and proven crates.

Question: How to use pattern matching in Rust?

In Rust, pattern matching is a powerful language feature that allows you to destructure data and match it against specific patterns. It helps you handle different cases and extract values from complex data structures with concise and readable code. The match keyword is used to perform pattern matching. Inside a match block, you define patterns and corresponding code blocks for each pattern. When the input data matches a specific pattern, the corresponding code block will be executed.

Weekly Rust Trivia: How to share state between threads

Thu, 27 Jul 2023 13:00:00 +0200

Question: How to share state between threads in Rust?

In Rust, we have the ability to share data between threads by using concurrent data structures and synchronization tools provided by the Rust standard library. The most popular concurrent data structures in Rust include Arc (atomic reference counting) and Mutex (mutual exclusion). These allow multiple threads to access shared data in a safe and synchronized manner.

Weekly Rust Trivia: How to write a function-like macro

Thu, 20 Jul 2023 13:00:00 +0200

Question: How to implement a function-like macro in Rust?

Function-like macros in Rust are powerful tools that allow you to define macros that resemble function calls. They can take in arguments and generate code based on those arguments. Function-like macros are defined using the macro_rules! keyword and a set of rules that define patterns and transformations. For demonstration purposes, we’ll define the factorial macro, which will generate code to calculate the factorial of a given number:

Weekly Rust Trivia: How to write an HTTP API with Actix

Thu, 13 Jul 2023 13:00:00 +0200

Question: How to implement the builder pattern in Rust?

To create an HTTP API with Actix, we must add the actix-web crate to our project. We can add it using cargo add:

# Add actix-web as dependency
cargo add actix-web

Having the crate added to our project, we can move on and use Actix to implement our HTTP API. First, we will implement two handlers, responsible for constructing HTTP responses. actix-web provides macros like post, get, … with which we can decrate our handler functions to describe how Actix should expose them via HTTP:

Weekly Rust Trivia: How to Implement the Builder Pattern

Thu, 06 Jul 2023 13:00:00 +0200

Question: How to implement the builder pattern in Rust?

The derive_builder crate provides a macro which allows us to satisfy the builder pattern for your individual structs without writing custom code.

First let’s add the dependency using cargo add:

Weekly Rust Trivia: How to Implement a Generic Stack

Thu, 29 Jun 2023 13:00:00 +0200

Question: How to implement a generic stack in Rust?

To implement a generic stack, we can simply create a custom struct wrapping a vector (Vec<T>):

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Stack<T> {
        Stack { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn size(&self) -> usize {
        self.items.len()
    }
}

The implementation (impl<T> Stack<T>) uses a generic type T to allow it to store any type of data. The Stack struct has four methods: new, push, pop, is_empty, and size:

Weekly Rust Trivia: How to Retrieve Image Dimensions

Thu, 22 Jun 2023 13:00:00 +0200

Question: How to retrieve the dimensions of an image in Rust?

The image crate provides necessary functionality to work with images in Rust. We can combine functionality provided by the crate with the path module from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to create a TCP Server

Thu, 15 Jun 2023 13:00:00 +0200

Question: How to create a TCP server in Rust?

We can use the io and net and thread modules from Rust standard library this trivia.

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle(mut stream: TcpStream) {
    // 64 KB buffer for demonstration purposes
    let mut buffer = [0; 65536];

    loop {
        let bytes_read = match stream.read(&mut buffer) {
            Ok(0) => return, // End of stream
            Ok(n) => n,
            Err(_) => return, // Error reading from stream
        };

        // Echo the data back to the client
        if let Err(_) = stream.write(&buffer[..bytes_read]) {
            return; // Error writing to stream
        }
    }
}

The handle function takes in a TcpStream object representing a client connection.

Weekly Rust Trivia: How to Implement Binary Search

Thu, 08 Jun 2023 13:00:00 +0200

Question: How to implement binary search in Rust?

All we need to implement binary search in Rust is bringing the cmp module into scope. The cmp::Ordering enum and the cmd::Ord trait provide everything required to implement a generic binary search supporting all types implementing the Ord trait.

Weekly Rust Trivia: How to Read a CSV File

Thu, 01 Jun 2023 13:00:00 +0200

Question: How to read a .csv file in Rust?

The csv crate provides necessary functionality to work with .csv files in Rust. We can combine functionality provided by the crate with the fs module from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

How to use Azure Cosmos DB as a key-value store for Fermyon Spin

Fri, 26 May 2023 10:04:05 +0200

With the 1.2.1 release of Fermyon Spin, we can now use Azure Cosmos DB as a key-value store for persisting data when building serverless applications. In this article, I guide you through setting up the necessary infrastructure and creating a fairly simple app to store and retrieve arbitrary values using Azure Cosmos DB as the key-value store.

All code shown in this article is also available on GitHub at https://github.com/ThorstenHans/spin-kv-azure-cosmosdb.

Provision necessary Azure Infrastructure

To use Azure Cosmos DB as a key-value store for a Spin application, we have to provision the following infrastructure components:

Weekly Rust Trivia: How to Compute a SHA256 Hash of a File

Thu, 25 May 2023 13:00:00 +0200

Question: How to compute a SHA256 hash of a file in Rust?

The sha2 crate is an implementation of cryptographic hash algorithms that we can use to compute hashes. We can combine functionality provided by the crate with the fs and io modules from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to Download an Image to a File

Thu, 18 May 2023 13:00:00 +0200

Question: How to download an image from the web and store it in a file using Rust?

The reqwest crate allows us to create HTTP requests with ease, we can combine functionality provided by the crate with the fs and io modules from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to Get all Files in a Directory

Thu, 11 May 2023 13:00:00 +0200

Question: How to get a vector (Vec<String>) containing all filenames of a particular directory in Rust?

We can use the fs and io modules from Rust standard library this trivia.

use std::{fs, io};

fn get_files_in_directory(path: &str) -> io::Result<Vec<String>> {
    // Get a list of all entries in the folder
    let entries = fs::read_dir(path)?;

    // Extract the filenames from the directory entries and store them in a vector
    let file_names: Vec<String> = entries
        .filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() {
                path.file_name()?.to_str().map(|s| s.to_owned())
            } else {
                None
            }
        })
        .collect();

    Ok(file_names)
}

In this example, we pass the path of the desired directory as argument to the get_files_in_directory function. We then use the fs::read_dir() method to get a list of all entries in the directory, which returns a std::fs::ReadDir iterator. We use the filter_map() method to filter out any None values from the iterator, then check whether each entry is a file or a directory using the is_file() method of the std::path::Path struct.

How I replaced the backend of my blog with Spin & Fermyon Cloud

Thu, 04 May 2023 15:53:49 +0200

Although my blog is built using Hugo - a famous Static Site Generator - I’ve some functionality baked into the page that requires having a backend (basically an HTTP API). Historically, the backend was hosted in Azure leveraging Azure Container Apps. Recently, I replaced the entire backend for my blog using a Fermyon Spin application hosted in the fully managed Fermyon Cloud. In this article, I explain how I migrated away from containers towards server-side WebAssembly with Fermyon Spin 💫.

A First Glance at the Spin Router for Rust

Tue, 18 Apr 2023 13:02:41 +0200

With the release of Fermyon Spin 1.1 (April 15th, 2023), the Spin SDKs for Rust and Go now provide a built-in router for HTTP applications. In this post, we will take a quick look at the built-in router supplied by the Spin SDK for Rust and build a small sample application to illustrate how one could solve day-to-day requirements when building serverless applications with WebAssembly (Wasm).

What’s the purpose of a router in HTTP apps?

In HTTP applications, a router serves as a central component to direct incoming HTTP requests to the appropriate handler functions that can process and respond to those requests. The router does so by looking at different parts of an incoming HTTP request, such as:

Let's build a HTTP router for Spin with Rust

Fri, 14 Apr 2023 11:13:43 +0200

Although we can build more complex HTTP applications in Fermyon Spin by composing multiple components, having a single component is easier, reduces development time, and is more flexible in the first place. In this article, I will explain how to implement simple routing capabilities using enumerations in Rust.

Let Spin lift your key-value store

Sat, 08 Apr 2023 15:41:09 +0200

For quite sometime now (since version 0.9.0), Spin has had built-in key-value support. In this article, we will quickly investigate how we can use that built-in key-value support when building serverless applications with Fermyon Spin.

What are key-value stores

A key-value store is a type of database that stores data as a collection of key-value pairs. Each key in the database maps to a corresponding value, which can be retrieved by querying the key. Key-value stores are often used for storing and retrieving data quickly, as they can perform reads and writes with very low latency. They are commonly used in web applications, caching layers, and distributed systems and can be implemented using various technologies, such as Redis, Cassandra, etcd, SQLite, and others.

CRUD in WebAssembly with Fermyon Spin and MySQL

Tue, 20 Dec 2022 16:32:11 +0100

With the latest release of Fermyon Spin (v 0.7.0), we can persist data in MySQL (persistence in PostgreSQL has been available for quite some time now). Being able to persist and retrieve some sort of data is a must-have for any kind of application.

In this article, we’ll take a look at a full-fledged CRUD implementation. We’ll build an HTTP-API that allows its users to Create, Read, Update, and Delete products using corresponding HTTP methods (POST, GET, PUT, and DELETE). All code shown in this article is available on GitHub at ThorstenHans/spin-crud-mysql.

Master configuration data in Fermyon Spin

Thu, 15 Dec 2022 14:01:01 +0100

Every application has to deal with configuration data, and applications built using Fermyon Spin are no exception here. Instead of baking configuration data into your source code, you should attach it from the outside to alter behavior of your applications without having to re-compile your source code.

This short article demonstrates how to deal with configuration data when building applications using WebAssembly and Fermyon Spin. You can find the source code of the sample application (spin-to-slack) on GitHub at ThorstenHans/spin-to-slack.

Azure Blob Storage using the Azure SDK for Go

Wed, 14 Dec 2022 08:18:27 +0100

The Azure SDK team reworked the SDK for Go and released a bunch of Go modules to interact with popular cloud services - not just from a management perspective. In this post, we will take a closer look at the Go-modules for interacting with blob storage capabilities offered by Azure Storage Account.

When interacting with Azure services, we must authenticate. The Azure SDK for Go supports different authentication patterns and flows. For demonstration purposes and to keep things simple, we’ll address two different authentication approaches as part of this article:

Building Microservices With WebAssembly and Fermyon Spin

Sun, 11 Dec 2022 15:18:16 +0100

Although WebAssembly is an excellent fit for bringing complex solutions that need near-native runtime performance to the client (Browser), I see WebAssembly as a technology with way more potential and a way bigger impact on the server (read: cloud) in contrast. That said, WebAssembly will not replace containers on the server side. It’s an addition or alternative approach to packaging and distributing specific software components typically part of a bigger system. It’s on us - the developers and software architects - to decide if a container or WebAssembly is the better foundation for meeting a particular requirement.

Hot-Reload .NET Configuration in Kubernetes with ConfigMaps

Tue, 06 Dec 2022 20:39:10 +0100

Leveraging ConfigMaps, we can inject configuration data into applications running in Kubernetes. In this article, we’ll look at how to use a Kubernetes ConfigMap to configure a .NET application from the outside and automatically reload changes applied to the ConfigMap.

Automatically reloading configuration data without redeploying the application and without doing a code change is super handy - not just for cloud-native applications. Being able to modify certain aspects of the application to hunt and pinpoint bugs is valuable and something you should consider adding to your applications too. For demonstration purposes, we will create a ConfigMap that allows us to modify the logging behavior of a simple HTTP API acting as the sample application.

Instrumenting .NET Apps with OpenTelemetry

Thu, 24 Nov 2022 12:13:00 +0100

Instrumenting applications is critical to address observability in cloud-native. Receiving detailed traces, metrics, and logs in distributed application architectures is mission-critical regarding monitoring and troubleshooting.

This article will look at OpenTelemetry and instrument a .NET application to ensure our overall application becomes observable at runtime.

What is OpenTelemetry

Before we dive into the actual example, let’s do a quick refresher on OpenTelemetry, to ensure everybody is on track. OpenTelemetry (often referred to as OTel) is an open-source observability framework. It is a CNCF (Cloud Native Computing Foundation) project and has been on the incubating maturity level since May the 7th of 2019. Historically, OpenTelemetry was started by combining two existing projects in the observability space OpenTracing and OpenCensus.

Background Workers in Azure Container Apps with KEDA

Mon, 17 Oct 2022 13:23:33 +0000

Azure Container Apps has quickly evolved and become one of the most popular platforms to run containerized workloads in Azure. This article will look at how to run Background Workers in Azure Container Apps leveraging built-in KEDA.

Developers can use Azure Container Apps to run simple cloud-native applications leveraging popular underlying technologies like Kubernetes, Dapr, and KEDA. Before we dive into building and running a background worker in Azure Container Apps, let’s do a quick refresher on what KEDA is and what it can do for us.

How to build multi-arch Docker Images with ease

Mon, 03 Oct 2022 13:25:44 +0200

With the rise of ARM-based cloud computing resources and Apple’s switch from Intel-based CPUs to Apple Silicon, building Docker Images for multiple architectures has become increasingly important. We, as developers, must ensure that our applications can be executed on every potential architecture. We can easily achieve that by using Docker CLI and the buildx plugin. This article will look at building Docker Images for multiple architectures by containerizing a simple Go application. Before we dive into building the multi-arch Docker Images, let’s quickly revisit what buildx is.

Provision AKS and NAT Gateway with Terraform

Fri, 09 Sep 2022 05:20:58 +0000

A Virtual Network NAT (NAT Gateway) is the recommended method for outbound connectivity when using Azure Virtual Networks (vNets). We can also use a NAT Gateway to route egress traffic from Azure Kubernetes Service (AKS), if the AKS cluster is deployed to a subnet associated with a NAT Gateway.

In this article, we’ll look at what NAT Gateway is, which benefits you get from using a NAT Gateway for outbound connectivity, and how we can provision both AKS and NAT Gateway using Terraform.

Patch Kubernetes objects with .NET: The Simple Way

Thu, 01 Sep 2022 15:54:07 +0000

By leveraging the official Kubernetes client libraries for C#, we can easily interact with any Kubernetes cluster. We can also update (or patch) existing objects by invoking the corresponding Patch* methods (like PatchNamespacedPod, PatchNamespacedConfigMap, and many more) provided by the client library.

Although we can construct patches from different formats (JsonPatch, ApplyPatch, MergePatch, or StrategicMergePatch), we’ll focus on JsonPatch for the sake of this article, and we will update the following ConfigMap:

How to Deploy Azure Container Apps with Terraform

Fri, 12 Aug 2022 18:56:47 +0000

Although we can provision and manage Azure Container Apps with Project Bicep (as explained in this article), people keep on asking how to manage their Azure Container Apps using HashiCorp Terraform. This article demonstrates how to provision Azure Container Apps with Terraform utilizing a combination of the well-known AzureRM provider (azurerm) and the recently released AzAPI provider (azapi).

Before we dive into provisioning a sample workload, let’s look at what the AzAPI provider is and how it works.

Let's build a gRPC server and client in Rust with tonic

Thu, 07 Jul 2022 17:13:13 +0200

Last week I was showcasing WebAssembly in the cloud using krustlet and Fermyon Spin at Cloudland 2022 in Brühl (Germany). While preparing for the talk, I recognized how much I’d missed Rust 🦀 over the past months.

Although I’ve been reading articles and watching some videos on Rust in general from time to time, I missed doing some hands-on. So I dedicated some time to do a quick refresher for Rust, updated my local installation rustup update, and wrote a small gRPC server in Rust using tonic. However, before we dive into the tutorial, let’s quickly look at what tonic is and what we can do with it.

Awarded as a Docker Captain and as a Microsoft MVP

Tue, 05 Jul 2022 19:02:29 +0200

Although we took ten days off and went to Egypt for vacation, the weeks were quite packed. Besides the entire family enjoying the stunning weather in Egypt, two things happened that I wanted to share with you.

First, I am humbled and honored to share that I got awarded as a Docker Captain in June 2022.

Docker Captain 2022

Joining an exclusive community of well-known, individual Docker experts means a lot to me. It’s a community where everyone is driven by passion for Docker and Docker-related technologies. Being surrounded by professionals that also share similar interests is priceless and made the program always appealing to me.

Docker SBOM - or how to dive into shift-left security

Tue, 03 May 2022 08:02:03 +0200

Recently, Docker added a new command to Docker CLI. docker sbom. We can use this command to create a Software Bill of Materials (SBOM) for any container image. Another great capability when it comes to shift-left security. This post explains why you should want to have SBOMs for all the container images of your application. How to get them and which actions you can take based on SBOMs to improve the overall security of your containerized workloads.

az containerapp up - AKA amazing inner-loop performance

Fri, 29 Apr 2022 16:32:22 +0200

The Azure Container App team released a new command to simplify the deployment process. With az containerapp up, you can deploy your workload to Azure Container Apps (ACA) with one command. This article demonstrates how to use az containerapp up and how you can tailor its behavior to meet your requirements.

What does `az containerapp up` actually do?

You can think of az containerapp up as a meta-command that will spin up all necessary resources to take your application source and run it in ACA. Under the covers, it does the following

How to lint Docker images with Dockle

Thu, 28 Apr 2022 19:26:56 +0200

We’ve been building container images for quite some time (read almost decades) now. Although tooling, editor, and IDE support have matured, we should not forget about hardening container images in the inner loop. This post demonstrates how to use Dockle to lint your container images according to security best practices.

Why should we lint container images

We’ve to talk about the „why". Why should we lint container images? We should lint container images to

Check if your application is running in a Docker container

Thu, 21 Apr 2022 17:22:42 +0000

Especially when building cloud-native applications, we tend to develop applications that run in any environment. We design components, so we can run them with or without container technologies to ensure we can host the application on different application platforms. However, sometimes we may have to determine if our applications are running inside a Docker container or not. This allows us to take particular actions at runtime without adding additional environment variables or configuration values (state). Every container has a .dockerenv file in the file system’s root. That said, we can quickly check for the existence of that file to determine reliably if our application runs inside a container or not. For demonstration purposes, this post shows how to determine if the application is executed in a container using Go and Rust.

Managed Identities With Azure Container Apps

Thu, 14 Apr 2022 13:21:20 +0000

Yesterday (13th of April 2022), we saw a couple of new features appearing in Azure Container Apps (ACA). This article will use managed identities with Azure Container Apps, which allows us to authenticate and rely on Role-Based Access Control (RBAC) when interacting with other Azure services. Before we dive into using managed identities in Azure Container Apps, let’s do a quick refresher about managed identities to bring everyone on track.

Speaker Bio

Tue, 12 Apr 2022 12:17:33 +0000

English Speaker Bio

Thorsten Hans is a Senior Developer Advocate at Akamai, Docker Captain, and Wasm enthusiast. He thrives on pushing the limits of WebAssembly and Edge Computing to help developers build high-performance distributed systems. Thorsten shares his technical deep-dives via his blog and on global stages to shape the cloud’s future.

German Speaker Bio

Thorsten Hans ist Senior Dev Developer bei Akamai, Docker Captain und Wasm-Enthusiast. Er liebt es, die Grenzen von WebAssembly und Edge Computing auszuloten, um Entwicklern beim Bau hocheffizienter, verteilter Systeme zu helfen. Seine Deep-Dives teilt er regelmäßig auf seinem Blog und auf den Tech-Bühnen dieser Welt.

Logging in Kubernetes with Loki and the PLG stack

Tue, 05 Apr 2022 13:30:00 +0000

Observability is a huge topic in cloud-native environments. One must collect, understand, and investigate millions of logs from different sources to understand what’s happening at an application’s runtime. Log stacks - like PLG - address all those concerns and are typically composed of multiple applications with dedicated responsibilities. At the core of every log stack, a log aggregation system is responsible for indexing, storing, and exposing a query interface for log messages.

Let's build a CLI in Go with Cobra

Tue, 29 Mar 2022 16:13:54 +0200

Cobra is perhaps the most popular Go-module to build powerful command-line applications (CLIs) in almost no time. This article will look at what Cobra is, its core concepts, and which features it brings to the table for building CLI applications.

https://github.com/spf13/cobra

Through this article, we will build stringer, a fairly simple CLI application. stringerallows its users to reverse and inspect strings. Although the feature set is not that big, it is just enough to use and understand the core concepts of Cobra.

Custom health probes with Azure Container Apps

Fri, 25 Mar 2022 11:41:56 +0000

In Kubernetes, individual probes like liveness, readiness, and startup are mission-critical when deploying applications. Kubernetes uses probes to determine the health of containers in a Pod. Kubernetes may restart Pods because of failing probes. On top of that, Kubernetes uses probes to determine if a particular container can deal with incoming requests. Kubernetes Services will route incoming requests to containers that made it to the Ready state. If a readiness probe is defined on a container, that container must successfully respond to the probe invocation to become Ready.

How to run your own Helm Repository on Azure Container Apps

Tue, 15 Mar 2022 15:29:00 +0000

Do you use Helm charts for packaging and deploying your stuff to Kubernetes? Have you ever thought about creating your own Helm repository to store and distribute your charts? This article explains how to take ChartMuseum and run it on Azure Container Apps backed by an Azure Storage Account. You can find all source code shown in this example in the 005-chartmuseum folder of my Azure Container Apps samples repository on GitHub.

Master Azure CLI queries - The missing manual

Wed, 09 Mar 2022 20:28:35 +0100

Have you ever used Azure CLI? Azure CLI is probably the best way to interact with Microsoft Azure and to automate recurring tasks in the context of Microsoft’s public cloud. However, I often see people writing fundamental shell scripts to execute more advanced queries or filter simple lists of elements returned from Azure CLI.

Although using shell scripts is an excellent way to get things done, it’s more time-consuming compared to learning all the capabilities that Azure CLI brings to the table. Microsoft provides some good documentation on how to write fundamental queries with Azure CLI. However, more advanced, real-world queries are not documented. This is why people start tinkering with shell scripts instead of using built-in capabilities. So let’s quickly catch up with fundamental JMESPath queries that every Azure CLI user should know.

Custom health probes with Application Gateway Ingress Controller

Wed, 16 Feb 2022 19:58:50 +0100

With Azure Application Gateway Ingress Controller (AGIC), we can integrate an existing Azure Application Gateway instance with Kubernetes. In Kubernetes, an ingress controller is responsible for routing inbound requests to applications running inside the cluster. AGIC automatically watches Ingress resources inside your cluster and automatically updates the linked instance of Azure Application Gateway upon reconciliation.

Azure Application Gateway uses health probes to determine if the desired backend target can serve requests. Azure Application Gateway won’t send incoming requests to the backend target if a configured health probe fails. Instead, it will respond to the request with an HTTP 502. If the health probe is successful, incoming requests will be forwarded to the desired backend target, responsible for handling the requests and generating proper responses.

Exposing gRPC services in Azure Container Apps

Mon, 07 Feb 2022 11:06:35 +0000

In my recent webinar on Azure Container Apps, an attendee asked if gRPC services could be exposed. Although I was pretty sure this was possible, I asked the attendee for some patience because I wanted to try this independently. Long story short, it’s possible. This post demonstrates how to expose gRPC services with a simple .NET 6 gRPC API and a corresponding client. We’ll also talk about a small glitch that may prevent your gRPC services hosted in Azure Container Apps from being accessible.

Automate Azure with Azure Functions and Go

Sat, 18 Dec 2021 10:52:45 +0000

Automation is key to success in the cloud. In this article, we will look at how to automate recurring tasks using Azure SDK for Go with Azure Functions. This article contributes to the Go Advent Calendar🎄. If you haven’t heard about it, you should check out all the awesome content contributed to the Go Advent Calendar and level up your Go programming skill during the holiday season.

The sample code shown in this article can be found in this repository on GitHub.

Manage ACR geo-replications with Azure CLI

Wed, 01 Dec 2021 17:02:05 +0000

With Azure Container Registry (ACR), we can use geo replications to deploy the service as close as possible to team members and regional application deployments. Azure Traffic Manager will route requests to the closes replication behind the scenes. Artifacts stored in the ACR instance will be synched between all geo replications automatically. I advise customers to use geo replications to

increase resilience (region outage will have no effect, services and users can consume container images from another geo-replication)
optimize container boot time in cross-region deployments (pull operations will be faster)
reduce costs for traffic (egress traffic to other regions)

To use geo replication in ACR, the Premium SKU is required. You’ll be charged with the ACR service fee per geo replication.

Let's build a serverless Christmas image tagging solution with Azure Computer Vision

Thu, 25 Nov 2021 15:06:37 +0000

By leveraging serverless capabilities provided by Azure, we can focus on actually building something instead of managing or taming the necessary infrastructure. Azure Computer Vision is one of those serverless capabilities you can use to build cool things rapidly.

Christmas 🎅🏼 is around the corner! That said, it’s time to gear up and flood social media with properly tagged images. To do so, we will build a simple serverless solution that tags all your Christmas images automatically.

Traffic split in Azure Container Apps

Thu, 04 Nov 2021 18:45:15 +0000

With Azure Container Apps (ACA), Microsofts latest serverless runtime for containerized workloads in Azure, we can customize certain aspects of traffic routing on the ingress level. This article will look at traffic split and configure a relatively simple API to leverage a tailored traffic split configuration in Azure Container Apps. If you are new to Azure Container Apps, consider reading my article “Introduction to Azure Container Apps” first.

What is traffic split

First, let’s quickly revisit what traffic split is. Traffic split is a mechanism that routes configurable percentages of incoming requests (traffic) to various downstream services. See the following picture, which shows the relation between ACA ingress controller, traffic split configuration, and downstream services (or revisions in the case of ACA):

How to deploy Azure Container Apps with Bicep

Wed, 03 Nov 2021 19:21:33 +0000

Although Azure Portal and Azure CLI provide a decent experience to deploy Azure Container Apps, I prefer using Infrastructure as Code (IaC) to deploy and manage my cloud infrastructure. That said, this post guides you through the process of deploying Azure Container Apps using Bicep.

!Note that container apps are moving namespace. In March 2022, ACA will shift from the Microsoft.Web namespace to Microsoft.Apps. Everything described here should still work, but you have to change the namespace!

Introduction to Azure Container Apps

Tue, 02 Nov 2021 23:36:24 +0000

During Ignite 2021, Microsoft announced the public preview of Azure Container Apps, a fully managed serverless container runtime for building and running modern applications at scale.

The announcement of #AzureContainerApps was definitely my personal highlight at #MSIgnite so far 🚀 pic.twitter.com/zbHaYotIWi
— Thorsten Hans 🦀 (@ThorstenHans) November 2, 2021

This article gives you a brief introduction to what Azure Container Apps is, which technologies are used to provide this fantastic serverless container runtime and how you can build and run containerized workloads on Azure Container Apps

Distribute WebAssembly modules as OCI artifacts

Tue, 02 Nov 2021 14:19:39 +0000

When using WebAssembly (Wasm) on platforms different than the browser, we have to care about distribution. How can we securely transfer our Wasm modules to desired environments? How can we verify integrity to ensure Wasm modules were not compromised during distribution?

Let’s take a look at the container world. Container registries (those that implement the Docker Registry 2.0 standard (or to be more precise, the OCI distribution spec)) are a trusted distribution channel that addresses all the questions raised before. This does not mean that we have to package our Wasm modules as containers! Container registries can store and distribute more than just containers. Container registries can store any OCI compliant artifact. And that’s exactly what we will create from our Wasm modules to leverage container registries as a trusted distribution channel.

Add krustlet node pools to Azure Kubernetes Service

Tue, 26 Oct 2021 14:23:42 +0000

If we had traveled three years back in time, running WebAssembly (Wasm) workloads in Kubernetes would have sounded like fiction. Today, it’s real! With krustlet, developers can run Wasm workloads directly in Kubernetes. This article will look at what krustlet is and how we can bring it to our Azure Kubernetes Service (AKS) clusters.

What is Krustlet

Krustlet is a Kubernetes kubelet written in Rust to run Wasm workloads in Kubernetes. Nodes running krustlet have special tolerations assigned, which we can use within Kubernetes manifests, to ensure Wasm workloads will be scheduled to krustlet nodes. Under the covers, krustlet uses wasmtime as the runtime for our Wasm workloads using the wasm32-wasi architecture.

Read-only filesystems in Docker and Kubernetes

Tue, 19 Oct 2021 13:31:43 +0000

You should harden your containerized workloads to minimize the attack surface of your overall application. Paying close attention while building your container images and applying proven patterns will reduce the risk of an attack while running your application in production. One of the simple practices to apply is setting the filesystem of your containers to read-only, and that’s exactly what we will cover in this article.

Read-only filesystems in Docker

Docker and compliant CLIs offer the read-only flag, which we can use when mounting the container’s filesystem as read-only. Let’s try it! Let’s start a new container from the official ubuntu image with an interactive TTY, to verify that the filesystem is read-only. The following docker run command uses -it (creates an interactive pseudo TTY and ensures STDIN is kept open) and --rm (removes the container automatically once exited):

How to Build CLIs in Rust with StructOpt

Mon, 11 Oct 2021 10:03:31 +0000

As my journey on learning Rust continues, I looked at several options for building Command-Line Interfaces (CLIs) in Rust. There are several crates available you can use to craft tailored CLIs in Rust. At some point, StructOpt got my attention, and I saw a couple of people tweeting and writing about it. That said, this article helps you understanding StructOpt and gives you a head-start when it comes to building custom CLIs in Rust.

Calling HTTP APIs in Rust with reqwest

Wed, 15 Sep 2021 11:31:00 +0000

As part of my Rust journey, I’m building a simple CLI to get rid of manual tasks I’ve to complete on regular basis. Some of those tasks can be automated by leveraging a HTTP client in Rust. A quick research led me to reqwest (https://github.com/seanmonstar/reqwest), a simple HTTP client for Rust that fits my needs and let me get the job done quickly.

You may ask yourself if reqwest is the best HTTP client for Rust? To be honest, I don’t know (yet). But I got my job done quickly, and I really enjoyed the API surface offered by reqwest. That said let’s dive into reqwest and see how it actually looks like.

External-DNS with Azure Kubernetes Service and Azure DNS

Thu, 09 Sep 2021 10:52:53 +0000

This article guides you through the process of configuring External-DNS with Azure Kubernetes Service (AKS) and Azure DNS. By deploying and configuring External-DNS and necessary Azure services correctly, you can ensure proper routing from your custom domain into Kubernetes. Before we dive into actually configuring External-DNS and wiring everything up, let’s briefly revisit some core concepts.

Cloud platform automation with managed Kubernetes clusters

Managed Kubernetes clusters like Azure Kubernetes Service (AKS) automate the surrounding cloud platform using their custom cloud controller manager implementation as part of their Kubernetes distribution. For example, this makes exposing a service of type LoadBalancer frictionless. AKS will automatically acquire a public IP address and provision an instance of Azure Load Balancer (LNB) to route ingress traffic into the Kubernetes cluster.

Shadowing and Temporary Mutability in Rust

Tue, 07 Sep 2021 18:37:36 +0000

Rust already amazes a lot when it comes to the basic language features. Let’s, for example, take a look at shadowing and temporary mutability. Both, fairly basic and simple language features, yet powerful and a real booster for robustness and correctness.

Shadowing in Rust

Shadowing is such a simple language feature. However, it has a significant effect on the code you write daily. Shadowing allows you to re-declare a variable in the same scope, using the same name. The re-declared variable differs from the original by having a different type. This is especially useful upon casting data from one type into another. In Rust, you can achieve this without adding unnecessary application-state.Take the following code as an example:

Working with Environment Variables in Rust

Mon, 06 Sep 2021 15:51:19 +0000

Rust makes working with environment variables fairly easy. The standard library provides fundamental APIs as part of std::env which we use to access environment variables inside of our application. If you’re expecting valid unicode values, you can use env::var - which returns an Result<String, VarError> - as shown here:

use std::env;

fn verbose() {
    let name = "USER";
    match env::var(name) {
        Ok(v) => println!("{}: {}", name, v),
        Err(e) => panic!("${} is not set ({})", name, e)
    }
}

fn short() {
    let v = env::var("USER").expect("$USER is not set");
}

In contrast, env::var_os does not check if the value of the desired environment variable is valid unicode. var_os has also a slightly different function signature, it returns an Option<OsString>:

Integrate Virtual Machine Scale Sets with Azure Monitor and VMInsights using Terraform

Fri, 03 Sep 2021 18:03:18 +0000

Cloud-Native does not mean “containers only”. Many organizations are still adopting cloud computing and trying to move their workloads into the cloud.

Recently, I helped a customer to bring long-running, compute-intensive workloads to Azure. The particular workload must run on Windows. Although most parts of the overall application are stateless, containerized, or even serverless, this component was special. We decided to leverage Azure Virtual Machine Scale Set (VMSS) to host that component.

Send a Microsoft Teams message when new OCI artifacts appear in Azure Container Registry

Fri, 27 Aug 2021 10:16:31 +0000

Getting instant feedback when a new artifact is published in a container registry such as Azure Container Registry (ACR) is important. Everyone has to stay in the loop, especially when working in a large team and managing many containerized applications. By leveraging ACR webhooks and the Microsoft Teams Inbound Webhook connector, you can easily send custom messages to a team for different activities happening in your container registry.

This article guides you through connecting ACR with Microsoft Teams to send messages automatically to a specific team when a new version of an image or an OCI compliant artifact is pushed to ACR.

Azure Functions with Go

Tue, 17 Aug 2021 13:15:14 +0000

By leveraging custom handlers in Azure Functions, we can use any programming language to build serverless applications and host them in Azure.Having the freedom to use your preferred programming language to craft Azure Functions is awesome. Developers can use their existing knowledge, tools, and frameworks. The integration with the surrounding runtime is done via a thin configuration layer.

For example, this post demonstrates how to build an Azure Functions project with a simple HTTP API written in Go. To keep things simple, we will use Gin, a minimalistic web framework for Go.

Encrypted Secrets in Helm Charts

Wed, 11 Aug 2021 08:00:44 +0000

In my recent article “How to encrypt Kubernetes secrets with Mozilla SOPS”, I demonstrated how to encrypt regular Kubernetes secret manifests (yaml) using SOPS CLI in conjunction with Azure Key Vault as the backend for the encryption-key.

This post will take it one step further; it guides you through the process of creating a custom Helm chart that will reference encrypted secrets. In the end, you will be able to add your encrypted secrets to source control without leaking sensitive information.

Encrypt your Kubernetes Secrets with Mozilla SOPS

Tue, 03 Aug 2021 12:59:24 +0200

By default, Kubernetes Secrets (secrets) are stored with base64 encoding in YAMLfiles. The lack of encryption for secrets often leads to the question of how to store secrets securely. Obviously, you don’t want to put your sensitive configuration data into a git repository, because it is just encoded. echo <base64_representation> | base64 -d.

A typical solution is using services like Azure Key Vault, or HashiCorp Vault to persist sensitive data. Those services can be integrated with Kubernetes by using the Secrets Store CIS driver. However, relying on an additional service means that you have to manage and maintain that service in addition to Kubernetes. Additionally, depending on the service you use to store your sensitive data, some sensitive configuration must be stored somewhere to configure the CIS driver.

Debugging apps in Kubernetes with Bridge

Wed, 28 Jul 2021 12:40:38 +0200

One of the most common questions I get when teaching developers in Kubernetes is

“How can I debug my application once it is deployed to Kubernetes?”

Although there are several ways how to achieve that, this post will explain and demonstrate how to debug applications running in Kubernetes using Bridge to Kubernetes (Bridge).

What is Bridge to Kubernetes

Bridge to Kubernetes (Bridge), the successor of “local process” is an IDE / editor extension. It allows developers to debug and test application counterparts (or microservices) on their local machine. While debugging locally, downstream and related components are consumed directly from within the Kubernetes cluster. Existing configuration objects - such as Kubernetes ConfigMaps, or Secrets -, and volumes mounted to the Pod are also applied to the local debugging instance seamlessly.

Bicep and Terraform compared

Mon, 26 Apr 2021 00:42:48 +0200

Infrastructure as Code (IaC) is an important technique when it comes to automation. Teams are starting their journey towards cloud-native often by automating everything. Infrastructure is no exception here. The continuously growing adoption of cloud services and digitalization are just some reasons why IaC tools like Terraform are so popular.

Project Bicep is the new kid on the block. Bicep is a new language that is created to express Azure infrastructures as code.

Closing down 2020 and approaching 2021

Thu, 31 Dec 2020 00:00:00 +0000

2020 was quite challenging for everyone. We made our way through the pandemic so far, and I hope this post finds all of you healthy. That said, I want to look back at 2020 share some numbers and do a quick a forecast for 2021.

Blog statistics

I am pretty satisfied with my blogging habits in 2020. But I did not publish consistently. I maintained a backlog of topics that I wanted to cover over the year. However, sometimes I struggled finishing articles. English is not my primary language, and creating posts takes more time than it actually would in German. Anyways, let’s have a look at the numbers:

Install Ubuntu Server 20.10 on a Raspberry Pi

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

Holiday time is tinker time. That said, I sat down to get some workloads up and running on my Raspberry Pi. I took some notes, that I want to share with you. This tutorial will guide you through the process of installing and configuring Ubuntu Server 20.10 on a Raspberry Pi.

Requirements

Only a few things are required to setup a fully functional Raspberry Pi with the latest Ubuntu Server release (Ubuntu Server 20.10):

Azure Cognitive Search integration for Static Site Generators

Thu, 17 Dec 2020 00:00:00 +0000

Finding appropriate content on websites and blogs boosts the user experience. With Azure Cognitive Search, you can quickly add professional search capabilities to your website. I use Jekyll to run my blog. However, the process described and explained in this post works for every Static Site Generator (SSG).

What is Azure Cognitive Search

Azure Cognitive Search (formerly known as Azure Search) is a fully managed service offering by Microsoft. Apache Lucene is the foundation of Azure Cognitive Search. Over the past year, Microsoft added a whole bunch of AI and Machine Learning (ML) capabilities. Microsoft renamed Azure Search to Azure Cognitive Search to align with other AI & ML service offerings. Although those features are pretty useful, searching website data is relatively simple and does not require any AI or ML features. Azure Cognitive Search can crawl data from different sources such as an Azure Storage Account, Azure SQL Databases, etc. Alternatively, you can actively push data into the search index using the Azure Cognitive Search Management SDK. There are SDKs for different programming languages available - in this article, you will see how to use the JavaScript SDK to push your data into the search index using Node.js.

Determine the size of Docker image layers

Tue, 15 Dec 2020 00:00:00 +0000

Let’s quickly recap what Docker layers are before we look at how to query their size. No worries, we look at the tip of the iceberg.

What are Docker layers

Every Docker image consists of layers. A single layer is the result of a particular instruction someone wrote down in a Dockerfile. Docker ads a new layer to the stack for each instruction of the Dockerfile. All layers together build the final Docker image.

Mastering Terraform Workspaces

Thu, 10 Dec 2020 00:00:00 +0000

Terraform workspaces (workspaces) are an easy yet powerful building block to create Terraform projects of any scale. In this article, I will guide you through all the details in the context of workflows. At the end of this guide, you take your Terraform projects to the next level.

What are Terraform workspaces

Think of workspaces as a layer of isolation for Terraform state files. Every workspace has its state file. All modifications applied in a particular workspace will never affect resources managed by another workspace. Workspaces are the key to manage multiple independent environments using a single Terraform project.

How to build smaller and secure Docker Images for .NET

Mon, 07 Dec 2020 00:00:00 +0000

TL;DR

This post explains how to optimize a .NET 5 Docker image and address two main concerns. Image size and security vulnerabilities. The article shows how to reduce the size from ~210 to ~58 MB. Additionally, it shows how to remove all 59 vulnerabilities.

What we get from Microsoft

Visual Studio (also Visual Studio for Mac) creates a relatively simple Dockerfile for .NET projects. It is a good starting point for users new to Docker. However, users should apply several optimizations before using the Dockerfile to create Docker images for production environments.

Run containers in Azure Container Instances straight from Docker CLI

Thu, 03 Dec 2020 00:00:00 +0000

A couple of months ago, both Microsoft and Docker announced the seamless integration of Azure Container Instances (ACI) and Docker CLI. As a container enthusiast, I had to look into this integration. I tested it in different scenarios to see how it could support me and increase my productivity.

tl;dr: The integration of ACI and Docker CLI is excellent. Once configured, I found myself spinning up numerous containers :). It provisions even multi-container applications based on Docker Compose. There is a downside. Pulling images from registries was slower compared to my local machine. Overall, I like the experience and share everything you need to know about it in this article.

Scan Docker images for vulnerabilities with Docker CLI and Snyk

Thu, 03 Dec 2020 00:00:00 +0000

Vulnerabilities are everywhere. Application developers use frameworks and libraries to solve business requirements. An operating system executes applications and their dependencies, and vulnerabilities could exist in each of those layers.

Obviously, as application developers, we fix potential vulnerabilities in our code-bases. However, fixing critical vulnerabilities in the Linux distribution our applications rely on, is probably not what we are responsible for. Often, it is more important to know which vulnerabilities exist and how we can fix them.

What is new in Open Service Mesh 0.4.0

Wed, 07 Oct 2020 00:00:00 +0000

A couple of days ago, Open Service Mesh (OSM) version 0.4.0 was released on GitHub. Compared to the previous release, several things have changed. In this post I will walk through the most important changes, which will have an impact on the actual usage of Open Service Mesh.

Sidecar Injection disabled by default

Open Service Mesh uses Kubernetes’ sidecar-container pattern to bring Service Mesh capabilities to your application deployments. With version 0.4.0, OSM will no longer inject sidecar-containers by default. In contrast, you have to enable it explicitly when onboarding a Namespace. This can be achieved by using osm CLI with the new --enable-sidecar-injection flag:

Getting Started With Microsoft Open Service Mesh

Fri, 28 Aug 2020 00:00:00 +0000

A couple of weeks ago, Microsoft announced the first public release of Open Service Mesh (OSM) an open-source, lightweight, and extensible service mesh implementation, based on the Service Mesh Interface (SMI) specification. This article explains the core concepts of a service mesh, provides an Open Service Mesh introduction, and demonstrates some common service mesh use-cases.

Update 2020-10-08

In the meantime, Microsoft has released version 0.0.4 of Open Service Mesh. The updates reflect the upstream changes.

Frictionless zsh And oh-my-zsh Management With Antigen

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

I love tinkering my shell environment. I found myself sitting down during the weekend and doing an overhaul of my configuration approach for ZSH. That said, I decided to change my ZSH plugin management and started using Antigen.

Antigen is a small set of helper functions that allow friction-less management of ZSH plugins. Personally, I was addicted to vim for decades and used vundle to manage my vim customizations. As the official Antigen website mentions: “Antigen is to ZSH what Vundle is to vim.”

How To Access Kubernetes Dashboard On RBAC Enabled Azure Kubernetes

Tue, 09 Jun 2020 09:00:00 +0000

The Kubernetes dashboard is quite useful to drill through existing Kubernetes clusters and inspect things without using kubectl. However, starting with version 2.0.40 of Azure CLI, Azure Kubernetes clusters are deployed with Role-Based-Access-Control (RBAC) enabled by default. Since that point in time, you will be presented with a bunch of errors when trying to access the traditional Kubernetes dashboard using az aks browse.

6 Steps To Run .NET Core Apps In Azure Kubernetes

Sun, 07 Jun 2020 08:00:00 +0000

Mastering Kubernetes is hard and a time-consuming task. However, getting started with Kubernetes in Azure as a .NET Core Developer is relatively easy. It takes six steps to get your application up and running in Azure Kubernetes Service (AKS), starting with a plain, regular .NET Core Web API.

This article will guide you through the entire process and explain all steps in detail, so you can follow and end up with having your application being executed in Kubernetes and being exposed to the internet.

5 Types Of ZSH Aliases You Should Know

Tue, 26 May 2020 00:00:00 +0000

My shell means everything to me. It is the first program I start in the morning and the last one I close in the evening. It is the program that I regularly tweak to boost my overall productivity. From my perspective, Microsoft’s release of Windows Terminal 1.0 and WSL 2.0 will boost overall Shell adoption. Over the past decade, I have seen numerous users installing and using different shells. However, the number of people that invest time in configuring their shell to be more productive is just a small percentage. And that is a shame!

Azure Arc enabled Kubernetes: Digital Ocean Kubernetes in Azure

Sun, 24 May 2020 08:00:00 +0000

During Microsoft Build Conference 2020, Microsoft demonstrated Azure Arc enabled Kubernetes, which allows you to connect and manage external Kubernetes clusters in Azure.

By attaching your existing Kubernetes clusters to Azure, you can use all the Azure goodness to control external clusters like any other internal Azure resource. Once connected, you can do certain things with the external Kubernetes cluster, like for example:

Add it to given Resource Groups
Categorize it using Tags
Access it via Azure Resource Graph
Apply Azure Policies to it
Protect with Azure Security Center
Collect metrics using Azure Monitor
Define cluster and application configuration with GitOps

This post explains how to connect a Kubernetes cluster running in Digital Ocean to your Azure Subscription by leveraging Azure Arc. Once connected, we will add some tags to the external cluster and query it using Azure Resource Graph to verify the connection.

Container Metrics With CTOP

Fri, 22 May 2020 00:00:00 +0000

A while ago, I stumbled upon ctop; a small, yet handy command-line tool to interact with Docker containers and gather essential metrics. You know docker stats? ctop is docker stats on steroids. The open-source tool is available for free and can be installed directly on Linux and macOS.

ctop - Essential metrics for Docker containers

With ctop, you get more than just fundamental metrics. Overall, ctop combines the following features in one single tool:

Azure CLI on the iPad - Azure CLI Tips & Tricks 3

Wed, 20 May 2020 00:00:00 +0000

Azure CLI Tips & Tricks is a collection of small, yet powerful things, that will boost your productivity when working with Microsoft Azure CLI.

I love my iPad Pro and the possibility to work from almost everywhere. Using the official Azure app from the Apple App Store, I can browse through my cloud resources and get essential information about cloud-based workloads.

Check metrics and resource status from anywhere
Start or Stop resources like VMs or Azure App Services at anytime
Receive notifications and alerts about service health issues

Additionally, the app comes with an integrated Cloud Shell, which gives me direct access to Azure CLI.

Docker Container CPU Limits Explained

Mon, 18 May 2020 08:30:00 +0000

If we think about Docker containers, we tend to associate words like efficient and small to them. Although this may be the case for the vast of situations, there are exceptions. There are containers that - perhaps unintentionally - have a very high CPU utilization. This post explains how you can limit CPU utilization for specific Docker containers to have better control of the overall hardware utilization.

On top of providing CPU limits for Docker containers, you should also limit the memory consumption. Consider reading my article, Limit Memory For Docker Containers, and learn how to prevent memory-intensive Docker containers from draining your overall system performance.

How to Clean ZSH History Temporary

Sat, 16 May 2020 00:00:00 +0000

I am super fussy when it comes to terminal configuration. I tweak my dotfiles now and then to optimize my workflow and improve my overall productivity.

I love having features like auto-suggestion. However, I work for different customers, and I do quite a lot of public speaking at developer conferences (or virtual events these days). In situations like these, I have to clean ZSH history entirely for the current terminal session, to prevent me from leaking sensitive information unintentionally.

Docker Container Memory Limits Explained

Fri, 15 May 2020 08:30:00 +0000

When running Docker Images locally, you may want to control how many memory a particular container can consume. Otherwise, it may end up consuming too much memory, and your overall system performance may suffer. By default, Docker does not apply memory limitations to individual containers. Containers can consume all available memory of the host.

No need to panic (for most of the users)! If you are using Docker Desktop, the host is actually a virtualized host. On macOS, the host is a virtualized system leveraging Apple’s Hypervisor framework (which has been released with macOS 10.10 Yosemite). We use the Docker Desktop app, to specify an overall limit for containerized workloads.

How To Run Commands In Stopped Docker Containers

Thu, 14 May 2020 00:00:00 +0000

You may already know the exec command, which allows you to execute a command inside of a running Docker container. This works excellent and will enable us to dive into a running container to inspect certain things like files in the file system, running processes, and other stuff. However, exec does not work when the Docker container stopped already. The following lines will explain and demonstrate how to run commands in stopped Docker containers.

Choose the best output format - Azure CLI Tips & Tricks 2

Tue, 12 May 2020 00:00:00 +0000

Azure CLI Tips & Tricks is a collection of small, yet powerful things, that will boost your productivity when working with Microsoft Azure CLI.

Azure CLI provides a bunch of different output formats. By default, it generates output using the json format. Although the default output format is both human-readable and descriptive, it is not the optimal format for every situation. Sometimes you need more focused responses, or you just want a good old ASCII-style table.

AKS cluster auto-scaler inside out

Mon, 11 May 2020 16:10:00 +0000

Cluster auto-scaling for Azure Kubernetes Service (AKS) is available for quite some time now. I have been using it in several projects so far.This post explains all details about the AKS cluster auto-scaler, shows how to enable it for both - new and existing AKS clusters - and gives you an example of how to use custom auto-scaler profile settings.

What is the AKS cluster auto-scaler

With cluster auto-scaling, the actual load of your worker-nodes will be monitored actively. By adding and removing worker-nodes from the cluster, it ensures that enough resources are available to keep your application healthy and responsive. In contrast, it removes worker-nodes from the AKS cluster, to optimize resource utilization and be as cost-effective as possible.

Get samples with az find - Azure CLI Tips & Tricks 1

Tue, 05 May 2020 00:00:00 +0000

Azure CLI Tips & Tricks is a collection of small, yet powerful things, that will boost your productivity when working with Microsoft Azure CLI.

az find is a useful command for every Azure CLI user. It is the go-to command, if you want to get scenario-based examples for Azure CLI commands. You can provide any command as positional argument to az find, and it will scan the official Azure documentation for examples.

ACR Unleashed – Use ACR As Registry For Helm Charts

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

The seventh and last part of Azure Container Registry Unleashed is about housing Helm charts in ACR. This post explains how to use ACR as a protected Registry for Helm charts. We walk through the process of creating, publishing, and consuming a sample chart from ACR. However, if you have not used or seen Helm 3 before, consider reading my “Getting started with Helm 3” article first.

What Is OCI And What Are OCI artifacts

On top of Docker Registry 2.0, Azure Container Registry supports OCI artifacts. The OCI specification defines a general format for interchanging various artifacts like Docker Images or application bundles such as Helm charts. The official definition of OCI’s responsibility is

Getting Started With Helm 3

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

Helm 3 is around for a couple of months now. During that time, I recognized more and more customers willing to use Helm 3 to package, distribute, and construct their cloud-native application bundles. Perhaps you have already heard of Helm, but don’t know where to start with Helm exactly? Or you want to learn the differences between Helm 2 and Helm 3. Again others, prefer having all essential information compiled into a single article. Then this is the right one for you! See this post as an introduction to Helm 3; it explains all the major building-blocks and provides - just - enough background information to get started with Helm 3.

Custom Validation Rules for Variables in Terraform

Tue, 21 Apr 2020 00:00:00 +0000

In Terraform, we use Variables to make projects configurable and to reduce code duplication. We can harden variables, by applying individual validations to them.

Obviously, providers like the official Azure Provider come with validations on resource attributes. For example, consider describing an instance of Azure Container Registry (ACR).

ACR has several required attributes, which must be provided by consumers. If consumers forget specifying a required attribute, Terraform will not try to provision it. Instead, the operation will fail and report a corresponding error message to the user, as shown in figure 1.

ACR Unleashed – Image Scanning With Azure Security Center

Mon, 20 Apr 2020 00:00:00 +0000

The sixth part of Azure Container Registry Unleashed is about scannig Docker Images in ACR using Azure Security Center. This post explains, what you get from Azure Security Center in the context of ACR and how to configure the integration of both Azure services. Before we dive into the article, I want to reach out and say thank you to my fellow MVP and well-known Azure security expert Tom Janetscheck for contributing to this article.

Free English Terraform Webinar on Thursday the 16th of April

Tue, 14 Apr 2020 00:00:00 +0000

My fellow MVP Damir Dobric organizes the local Azure Meetup in Frankfurt. We know each other for many years and meet several times a year at different conferences. Back in September 2019, we met in Mainz during BASTA! 2019 and decided to do a local Meetup in Frankfurt and talk about Terraform in the context of Microsoft Azure. Due to the global impact of Coronavirus, we decided to transform the meetup into a virtual meetup.

Free German Terraform Webinar on Wednesday the 15th of April

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

At Thinktecture, we have started a new, free webinar series to share experiences from real-world projects to demonstrate technologies and practices we believe in and love. As part of the webinar series, I will do a free online webinar in German on Wednesday the 15th of April 2020 at 10:30 (CEST).

You can register for the webinar for free, using this registration link.

During the webinar, I will explain what Terraform is and why you should care about it. You will learn how to build infrastructures for Microsoft Azure using Terraform and the HashiCorp Configuration Language (HCL). Additionally, I will explain how we structure large scale Terrform projects and demonstrate how to slice modules to increase re-use of infrastructure components. During the webinar, I will explain what Terraform is and why you should care about it. You will learn how to build infrastructures for Microsoft Azure using Terraform and the HashiCorp Configuration Language (HCL). Additionally, I will explain how we structure large scale Terrform projects and demonstrate how to slice modules to increase re-use of infrastructure components.

3 Ways to integrate ACR with AKS

Wed, 12 Feb 2020 00:00:00 +0000

To integrate Azure Container Registry (ACR) with Azure Kubernetes Service (AKS), operators and developers currently have three different options. At the end of the article, you can integrate the protected implementation of Docker Registry 2.0 with your Kubernetes cluster using your preferred strategy.

1. Kubernetes Secret

First and perhaps the easiest integration strategy is to create a Kubernetes Secret of type docker-registry. You can create such a Secret either using yaml or using the kubectl create command:

Extend Kubernetes with Custom Resource Definitions and RBAC for ServiceAccounts

Tue, 11 Feb 2020 00:00:00 +0000

We can extend Kubernetes using Custom Resource Definitions (CRDs). By adding Custom Resource Definitions to Kubernetes, operators can use familiar concepts and tools like kubectl to deal with custom data. We can bring our schema and have it sitting next to first-class types like Pod, Service, and others. Kubernetes API Server takes care of the entire lifecycle of custom objects, which means once CRDs are deployed, we can create, modify, retrieve, and delete them. On top of that, we can create custom Roles and ClusterRoles to protect custom objects using RBAC.

ACR Unleashed – Tasks

Wed, 05 Feb 2020 00:00:00 +0000

The fifth part of Azure Container Registry Unleashed is all about automating things in the context of Docker Images and ACR. Starting from scratch with simple, yet useful ACR Quick Tasks, over regular ACR Tasks to full-fledged ACR Multi-Step Tasks, this article covers everything you need to know about Tasks in ACR.

What Are ARC Tasks

With Azure Container Registry (ACR), customers can use so-called tasks to offload several workloads from local machines, and services such as GitHub or Azure DevOps to Azure Container Registry. With ACR Tasks, customers can build, push, and run Docker Images for different platforms, including Linux, Windows, and ARM. As of today, there are three different types of Tasks available in ACR:

European Azure Conference 2020

Tue, 04 Feb 2020 00:00:00 +0000

I am thrilled to join the announcement of the European Azure Conference 2020 (EAC20). While Microsoft just finished celebrating the 10th birthday of Azure, we want to add another reason to be excited about Azure.

From 2nd till 4th of June 2020, Azure enthusiasts from all over the world will meet in beautiful Nice (France) to celebrate the first iteration of this independent and dedicated Azure conference in Europe.

During the three-day event, we will deliver outstanding Keynotes, 8 tutorials, and more than 70 sessions covering all areas of Microsoft Azure.

API Summit - IaC for everyone with Terraform

Tue, 10 Dec 2019 00:00:00 +0000

This week, API Summit 2019 took place in Berlin. I was invited to demonstrate some Infrastructure as Code (IaC) goodness and talk about Terraform.

During my half-day tutorial, I explained how to create multi-cloud infrastructures for Azure and AWS using HashiCorp Terraform. Additionally, we used git flow to establish a proper collaboration workflow.

All samples are available on GitHub.

Additionally, you can cycle through the slide-deck right here.

ESPC 2019 - Interview

Thu, 05 Dec 2019 00:00:00 +0000

Fabian Williams (fellow MVP and good friend of mine) interviewed me during European SharePoint, Office365 and Azure Conference (ESPC19). We had a great conversation about different topics which I focus on these days. Basically, we talked about

Microsoft Azure
Infrastructure as Code
Engagement in the developer community
How to participate and contribute to the community

Additionally, we talked about how ESPC has evolved over time and how it addresses latest and greatest technology trends. The interview was filmed and is available for free, in full length on YouTube.

ACR Unleashed – Webhooks

Wed, 04 Dec 2019 00:00:00 +0000

In the fourth part of Azure Container Registry Unleashed, we will dive into webhooks offered by ACR and learn how to use them to build simple, yet powerful automations based on ACR interactions such as pushing new tags of an image.

What Is A Webhook

Before we dive into ACR webhooks, let us do a quick refresher on webhooks. However, if you are familiar with webhooks, skip this paragraph and move on to (ACR webhooks).

ESPC 2019 - Code your Azure with Terraform

Tue, 03 Dec 2019 00:00:00 +0000

This week European SharePoint and Azure Conference (ESPC19) takes place in Prague. I had the chance to give a talk on Terraform as part of the Azure track.

My talk was all about adopting Infrastructure as Code (IaC) in the Azure space.

During the talk we built three different environments (development, staging and production) with slightly different configuration. If you want to look at the final solution, checkout the demo-code on GitHub.

Docker on Windows - Fix Time Synchronization Issue

Wed, 27 Nov 2019 00:00:00 +0000

During validation of Windows as main operating system (which is still ongoing), I experienced strange issues when trying to build my blog using the jekyll/jekyll Docker Image running on Windows 10.

At some point, jekyll build printed strange warnings that my shiny new article wont be compiled because it has a date in future.

I checked the filename and frontmatter metadata of the post. However both looked good. So I dived a bit deeper and recognized that the date within the container was set to 25th of November whereas my host system was displaying the 27th of November.

ACR Unleashed – Integrate ACR And Azure Monitor

Tue, 26 Nov 2019 00:00:00 +0000

The third part of Azure Container Registry Unleashed will guide you through the process of integrating ACR and Azure Monitor to collect essential information and metrics about your ACR instances at runtime. The integration of ACR and Azure Monitor is currently in public preview. However, retrieving insights about your ACR instance is mission-critical, so we will dive into this topic now.

What Is Azure Monitor

Azure Monitor is a centralized hub for aggregating, analyzing, visualizing and working with data. It consumes data from different sources and collects that data in data stores. All data collected by Azure Monitor fits into on of two categories, logs and metrics.

ACR Unleashed – Authentication, Identity Access Management And Content-Trust

Thu, 21 Nov 2019 00:00:00 +0000

This is the second part of Azure Container Registry Unleashed. Today, we will go one step further and talk about Authentication (AuthN), Identity Access Management (IAM) and Content-Trust in the scope of ACR. To be a bit more precisely, this post contains the following sections:

ACR Authentication

As mentioned in the first post of the series, Azure Container Registry integrates seamlessly with Azure Active Directory (AAD) and offers several ways to authenticate. Basically, you should differentiate between user-involved authentication and headless authentication, which is typically issued by a service in service-to-service scenarios. Having all authentication calls separated into those two categories, finding the correct authentication-pattern becomes easier.

ACR Unleashed – ACR Up And Running with Geo Replication

Tue, 19 Nov 2019 00:00:00 +0000

Azure Container Registry – or short ACR - is a managed service offered by Microsoft Azure. It is a private Docker Registry based on Docker Registry 2.0 and acts as central service in many containerized application architectures. Compared to other private Docker registries, ACR offers several advantages like ease of administration due to powerful Azure CLI commands, seamless integration with other Azure Services such as Azure Kubernetes Service and frictionless authentication using Azure Active Directory (AAD).

Book review - Kubernetes Up & Running 2nd Edition

Sat, 02 Nov 2019 00:00:00 +0000

A couple of days ago, I stumbled upon a tweet from Brendan Burns mentioning that the 2nd edition of “Kubernetes: Up & Running” is available. Because I enjoyed the initial release of the book some years ago, I bought a copy and read it. Brendan Burns, Joe Beda, and Kelsey Hightower updated their popular book “Kubernetes: Up & Running” to provide a good Kubernetes introduction for developers. On less than 300 pages, you will learn what Kubernetes is and which needs it addresses.

Certified Kubernetes Application Developer - Review and Tips

Tue, 22 Oct 2019 00:00:00 +0000

During this week, I took the Certified Kubernetes Application Developer (CKAD) exam and passed. However, I did not take the exam because of the certificate; I took the exam because of the challenge. The challenge to verify my Kubernetes knowledge and experience. The knowledge and experience I got from real-world projects and from falling in love with cloud-native application development in general.

Compared to other exams (and I did a bunch of exams back in the .NET Framework v3 and v4 days), CKAD is challenging. There are no multiple-choice questions, CKAD challenges your experience with Kubernetes by presenting you with a set of day-to-day tasks. Tasks that you must solve in 120 minutes or less by using a terminal and an editor. I enjoy challenges like these. They make me identify areas where I can improve because they measure both: Experience and speed.

Join my webinar about Terraform and Azure during Azure Week

Thu, 10 Oct 2019 00:00:00 +0000

We are getting closer to the European Azure and SharePoint Conference 2019 (ESPC2019), which takes place during December 2019 in Prague.

A couple of speakers (all focussing Azure related topics) and myself agreed on delivering a vast amount of free content to ramp up your Azure skills before ESPC19.

We will celebrate Azure week starting the 14th of October and have a great schedule for you.

I will contribute a webinar about Terraform and Azure on Friday the 18th of October at 11 am CEST. You can register for the webinar here.

AKS and ACR Integration - Revisited

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

Back in 2017, I published this article on integrating Kubernetes with ACR. Since that time, a lot has changed in the world of containers and orchestrators. Especially Microsoft is pushing hard in the Kubernetes area and keeps on shipping features regularly as part of their managed Kubernetes offering. The integration of ACR and AKs became even more comfortable since Azure CLI 2.0.73 has been released. That said, let’s check out how smooth the integration is.

The state of Helm 3 - Hands-On!

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

Helm, is the package manager for Kubernetes. It allows you to install complex applications and maintain the entire application lifecycle using a lightweight and intuitive CLI. You can think of it as the npm or nuget for Kubernetes.

Helm is around for quite some time in the Kubernetes community. The project was started by Deis and Google and is an essential part of CNCF.

Since Helm 3 is available as a beta release, it is the right time to look into it. This article summarizes the upcoming changes and illustrates how Helm 3 could be used to build, distribute, and manage applications in Kubernetes.

Custom domains in Azure Kubernetes Service (AKS) with NGINX Ingress and Azure CLI

Mon, 30 Sep 2019 00:00:00 +0000

When running applications in Azure Kubernetes Service (AKS), NGINX Ingress does a great job in routing inbound traffic. The flexible routing engine allows a wide variety of scenarios to expose different parts of cloud-native applications using different URLs. Unfortunately, there is no documentation on how to map such a custom domain to a public IP address without using the Azure Portal.

This article outlines the process of mapping a custom domain to the public IP address acquired by NGINX Ingress in AKS using Azure CLI. I assume you have already deployed your application and corresponding NGINX Ingress to your AKS.

Six golden rules of Infrastructure as Code (IaC)

Mon, 06 May 2019 00:00:00 +0000

Infrastructure as Code (IaC) is the process of describing all required infrastructure (such as servers, services or databases) to run your service or application. In this article, I want to share my six golden rules of Infrastructure as Code.

Over the past couple of years, IaC gained a lot of traction; more and more people are interested in persisting all their infrastructure-related knowledge in code to collaborate on it and establish a common understanding of it and get rid of that critical project risk. However, IaC solutions should be treated like every other primary part of your solution and follow some rules. I’ve seen many IaC solutions and compiled the following six rules, which will help you building robust Infrastructure as Code solutions for your projects.

Terraform - State demystified

Sat, 30 Mar 2019 00:00:00 +0000

State Management is essential in Terraform. This post explains what State in Terraform is, how it is mutated and how you should deal with it - no matter if you’re a one-person show or part of a development team.

Having Terraform displaying detailed previews before applying modifications to cloud platforms is amazing. To deliver such a great experience, Terraform uses the so-called State. This article will explain what State is, how it works and why it is mission-critical.

Terraform - The Definitive Guide for Azure Enthusiasts

Tue, 12 Feb 2019 00:00:00 +0000

Terraform is a product in the Infrastructure as Code (IaC) space, it has been created by HashiCorp. With Terraform you can use a single language to describe your infrastructure in code. This guide explains the core concepts of Terraform and essential basics that you need to spin up your first Azure environments.

What is Infrastructure as Code (IaC)

Infrastructure as Code (IaC) is the process of describing infrastructural components such as servers, services, or databases using a programming language. Once all infrastructural requirements are described in code, that code can be stored in source control.

Azure Key Vault FlexVolume for Kubernetes — A journey to integrate Azure Key Vault and AKS

Mon, 10 Dec 2018 00:00:00 +0000

This is the second part of the mini-series on Integrating Azure Key Vault and AKS (Azure Kubernetes Services). If you missed the first part, you should definitely read it before digging into this article.

Introducing Azure Key Vault FlexVolume for Kubernetes

Azure Key Vault FlexVolume for Kubernetes is a driver that allows you to consume typed data from Azure Key Vault (like secrets, keys or certificates) and attach that data directly to Pods. You can find the project itself directly on GitHub.

AzureAD Pod Identity in AKS: A journey to integrate Azure Key Vault

Thu, 06 Dec 2018 00:00:00 +0000

Back in May, I wrote an article on how to integrate Azure Key Vault with ACS. Since that, a lot happened in the Azure and Kubernetes space and I thought an updated version would be worth sharing because dealing correctly with sensitive data is essential.

This is the first of two separate articles, that will guide you through the complete setup and configuration process to integrate Azure Kubernetes Services and Azure Key Vault securely without leaking essential data about your Service Principal.

Inspect your Kubernetes inventory in no time with ASP.NET Core and Kubernetes Client Library

Tue, 04 Dec 2018 00:00:00 +0000

Running and maintaining complex applications on Kubernetes often requires good monitoring capabilities. Sure, there are plenty of products available which can be deployed easily to an existing cluster to get insights about the current cluster inventory. But why not build your own?

In this post, I’ll guide you through the process of creating a simple ASP.NET Core Web API to expose your cluster’s inventory - such as Pods for example - to other applications in order to get exactly those insights that are important for you. I used the following example frequently during public talks to explain the core concepts of Kubernetes to .NET developers.

Integrating Azure Key Vault with Azure Container Services

Fri, 11 May 2018 00:00:00 +0000

With Azure Key Vault, Microsoft is offering a dedicated and secure service to manage and maintain sensitive data like Connection-Strings, Certificates, or key-value pairs.

We’re hoping to see a native Azure Key Vault integration for Azure Container Services (ACS) in the near future. At least the official FAQ mentions the feature on the product’s roadmap. Until this features will be shipped and if you’re using another Kubernetes environment - such as GCP or AWS offerings -, you’ve to integrate Azure Key Vault manually into your application building blocks to get rid of storing most sensitive data in plain old Kubernetes Secrets.

Limit resources for containers with LimitRanges in Kubernetes

Thu, 22 Mar 2018 00:00:00 +0000

When deploying applications to Kubernetes one of the most important things to specify are resource-requests and -limits. Having proper limits defined per Container makes it easier to optimize the hardware utilization for all worker nodes in a Kubernetes cluster.

When creating deployments, you can set resource-requests and -limits by using the resources property on each container as part of the podspec. See the official documentation for further information.

Unfortunately, those properties are not mandatory, so every developer has to remember providing requests and limits for both memory and cpu.

Upgrading a Kubernetes cluster on AKS using Azure CLI

Thu, 22 Mar 2018 00:00:00 +0000

Upgrading an on-premises Kubernetes cluster can be very cumbersome and time-consuming task. It’s not just a single upgrade command that you can execute and everything happens magically behind the scenes. A single command for upgrading an entire Kubernetes cluster would be awesome 💚 and that’s exactly what’s provided by the AKS team. A single command to upgrade all your masters and nodes.

My fellow MVP Tobias Zimmergren wrote a great post on how to upgrade AKS clusters a couple of weeks ago. But technology and tools are changing quickly these days.

CronJobs on AKS using Azure Files and .NET Core

Wed, 21 Feb 2018 00:00:00 +0000

Tasks need to be executed repeatedly in almost every application. We all know requirements like these. Perhaps you have to clean up some tables in the database or you’ve to delete temporary files, no matter which requirement you’ve exactly, but CronJobs in Kubernetes are exactly designed for scenarios like these. Kubernetes offers CronJobs as first-class citizen objects. In the scope of Kubernetes, a CronJob should be used if you want to execute a piece of software either at a specified point in time or repeatedly at specified points in time. Technically it’s just a regular Pod with a schedule definition. You’ve to provide your schedule using the good old cron format.

Deploy Azure Functions to Kubernetes and scale them automatically

Fri, 26 Jan 2018 00:00:00 +0000

Azure Functions has become my standard framework to build serverless backends for Single Page Applications (SPAs). It’s easy to get started with Azure Functions, although the platform itself is really powerful and highly configurable. I really love the cloud hosting capabilities for Azure Functions, but from time to time, it’s not allowed to use the public cloud as the deployment target.

Azure Functions can easily be hosted in different environments. You can download the entire runtime and execute it on-premises (if you have to) or you can use the existing Docker image and deploy your serverless backend to Kubernetes. And that’s exactly what this post will describe, you’ll create a sample Azure Functions project including a docker container, deploy it to a Kubernetes cluster and let it automatically scale based on CPU utilization.

Hybrid Kubernetes Cluster on Azure Container Services

Sat, 26 Aug 2017 00:00:00 +0000

Using Azure Container Services (ACS) you can easily build hybrid kubernetes clusters. In this context, hybrid means that you’ll end up having a kubernetes cluster with both, Linux Nodes and Windows Nodes.

In this article I’ll guide you through the process of creating a new hybrid kubernetes cluster on Azure Container Services.

Prerequisites

When starting from scratch, you need only a few things:

a Microsoft Azure Account
a Text Editor
a local installation of kubectl
Azure CLI 2.0 installed on your machine

Configuring Azure CLI

Once you’ve all the prerequisites in place, it’s time to care a bit about our Azure Subscription.

What to do if Pods stuck in state Pending while deploying to Azure Container Instances

Thu, 24 Aug 2017 00:00:00 +0000

Azure Container Instances (ACI) allows you to spin up containers in the cloud without creating or managing any kind of infrastructure. It’s really bringing container as a service to you. That said, ACI is no replacement for Container Orchestration Systems like Kubernetes. It’s more an underlying infrastructure for hosting/running containers itself.

ACI integrates seamlessly with orchestrators like Kubernetes. You can use the ACI connector for Kubernetes to create an ACI node on your Kubernetes cluster. See this repo for more details.

Autocompletion for kubectl and aliases using oh-my-zsh

Tue, 22 Aug 2017 00:00:00 +0000

Kubernetes is managed and used by utilizing the command line interface kubectl. I got a ton of questions regarding my terminal configuration for daily k8s tasks. Questions like “Which aliases do you use for regular k8s tasks?” or “How did you get autocompletion for all the k8s stuff up and running on your mac?” So this post will answer those questions quickly to ensure everyone will become more productive and can spin up even more pods and nodes in less time 🚀

Using Azure Files in Kubernetes Deployments with ASP.NET Core

Mon, 21 Aug 2017 00:00:00 +0000

Azure Container Services (ACS) makes it incredibly easy to spin up and manage Kubernetes clusters in the cloud. There are plenty of other Azure resources which you can use to build daily scenarios on a native cloud stack. Common scenarios are serving files from and writing important information to persisted locations. Azure offers many different storage capabilities. In this post, I’ll explain how to use an Azure File Share to serve content by using a .NET Core Web API.

How to use a private Azure Container Registry with Kubernetes

Fri, 18 Aug 2017 00:00:00 +0000

Besides using the goodness of Azure Container Services (ACS). Different Azure services like Azure Container Registry (ACR) and Azure Container Instances (ACI) can be used and connected from independent container orchestrators like kubernetes (k8s). This post will explain how to set up a custom ACR and connect it to an existing k8s cluster to ensure images will be pulled from the private container registry instead of the public docker hub.

KISS  Angular apps a bit more framework agnostic

Tue, 07 Mar 2017 00:00:00 +0000

More and more developers are jumping on the Angular train in these days. Angular is awesome 💚🤘🏼 but it’s just a framework, a framework that may be replaced at some point in time by the next big thing.

Hopefully, the next big thing will also be an Angular thing 😀

But to be honest, nobody can tell. Fast forward a few years and you’ll find yourself being responsible for migrating an existing old Angular 4.0.0 app to the cool, new kid. As soon as this will happen, you’ll hopefully remember this post. I’m going to share small, easy to adopt steps to make your Angular apps a bit more framework agnostic.

Make writing technical content great again!

Sat, 04 Mar 2017 00:00:00 +0000

Like many other developers, I write articles for various print and online magazines. I do this for almost a decade now and I’ve used many different approaches to make writing as comfortable as possible for me. That said, I want to share the tools I use and the workflow I prefer.

When writing about frameworks, programming languages or scripts, you’ve some slightly different requirements than authors of regular books or articles. You want to:

Electron CrashReporter - stay up to date if your app fucked up!

Fri, 03 Mar 2017 00:00:00 +0000

Every one of us knows about those situations. You ship your app to production and you’re instantly losing 10 pounds of weight 💪🏼 if nothing bad happens in the first 24 hours. You’re finally able to get some sleep, customers are happy, the manager is happy, you are happy!

But at some point in time your app will crash! It will definitely crash. No matter how professional you are, there are bugs! Customers will find them! And that’s okay.

Integrating Angular and Electron using ngx-electron

Fri, 24 Feb 2017 00:00:00 +0000

GitHub Electron makes crafting cross-platform desktop applications really simple. You can take any existing website or Single Page Application (SPA) and just wrap it into a native container. Those containers (powered by Chromium and Node.js) could easily be distributed to all major desktop operating systems like Windows, macOS or Linux.

On the other side is Angular as a full-blown application framework for building robust SPAs. Angular makes building SPAs fun and provides a rich set of APIs to get everything done, inside of the client. However, sometimes you need a deeper integration. For example, you want to call into Electron’s main-process to execute some Node.js script like reading files from a directory or do some other processing using Node.js. In those cases, you could utilize Electron’s APIs.

Standard Angular Pipes and ng-translate

Thu, 23 Feb 2017 00:00:00 +0000

Of course is Angular itself shipping with some i18n (internationalization) APIs, but ng-translate has become the new default for many developers to provide translations within Angular apps.

Personally, I prefer ng-translate over built-in i18n APIs because it is fast, easy to explain and it allows to run multilingual apps without having the requirement to have dedicated hosting for each language.

One of the disadvantages is, that ng-translate doesn’t provide Pipes as Angular does. Angular ships twelve useful Pipes, including things like DecimalPipe, DatePipe or the CurrencyPipe. Some of those standard Pipes offer a simple way to format values directly within HTML templates.

Treat your iTerm2 like Guake

Sat, 15 Oct 2016 00:00:00 +0000

iTerm2 is a real productivity boost for macOS users. There are numerous great features built in the terminal replacement. This article will explain how to configure the hotkey window iTerm is offering.

Over the past couple of weeks, I found myself using Ubuntu quiet often. Unfortunately, iTerm2 isn’t available for Ubuntu, but there is Guake which is another powerful terminal. The experience and integration Guake is offering for Linux distributions is amazing, Guake registers a global shortcut to easily open the terminal no matter where you’re currently working on.

HTML5 notifications in electron apps with Angular

Fri, 22 Jul 2016 00:00:00 +0000

Within Electron apps, you can use HTML5 Notification API to keep users posted about events happened. Electron is bridging incoming calls to HTML5 Notification API to native notification APIs offered by all supported platforms.

Create a notification

Creating new notifications is straightforward. An instance of the Notification class is all you need. In the most basic shape, notification consists of a title. Additional metadata could be provided by providing an object as the second parameter to the Notification constructor, as demonstrated below with body.

Using Augury inside of Electron Apps

Sat, 02 Jul 2016 00:00:00 +0000

Writing apps using GitHub’s Electron is a reasonably easy task. The framework and community-driven tools are taking away much pain from you as a developer. Nevertheless, it is essential to have powerful debugging tools working in every environment. Augury (created by Rangle.IO) is currently the most powerful debugging tool for Angular developers. It’s a Chrome Extension that works perfectly inside of the Browser, in this post, you’ll learn how to use Augury inside of your Electron apps.

Angular Quickie - Why can't I compile my Angular app anymore

Mon, 15 Feb 2016 00:00:00 +0000

Staying on top of the technology stack is sometimes really hard. The Angular core team tries to do it’s best to keep breaking changes as seldom as possible. Because Angular is still in beta, breaking changes may happen. I was facing some issues while catching up latest betas. If you’re also facing TS2304 while transpiling your app, this article may help.

After pulling a remote branch from git this morning, I tried to start a simple Angular project by invoking our Gulp.JS tasks. However, suddenly the script crashed and printed tons of errors from the TypeScript Compiler (short tsc). After some short discussion, I decided to dig deeper into the issue and tried to fix the issue and understand why this has happened.

Angular and Electron - The definitive guide

Sun, 14 Feb 2016 00:00:00 +0000

Building cross-platform apps for desktop operating systems became simple compared to the past. With GitHub’s Electron is a framework available that takes away the pain for abstracting all common platform APIs from us as web developers.

Electron makes it easy to host Single Page Applications (short SPAs) within a native application container which is available for macOS, Linux, and Windows. When looking at Electron’s architecture, you will find two main counterparts.

Angular Quickie - Async Routes

Tue, 09 Feb 2016 00:00:00 +0000

Angular ships with its component router. The router makes it easy to compose complex applications from a bunch of components. Multiple routers could easily be nested to achieve almost every requirement for a SPA. When using regular routes, all files from your SPA are transferred to the client as soon as RouteConfig is interpreted by the JavaScript engine of your browser.

With growing apps, you may change this behavior. Clients should only download those files that are required for the current use case. Alternatively, you would initially transfer only those files required to make the core functionality of your app work. Optional components and templates should only be transferred if users request those components explicitly.

NW.js and Electron compared

Tue, 09 Feb 2016 00:00:00 +0000

I’ve spent much time doing cross-platform development over the past year with a significant workload on cross-platform desktop development.

During that time, I found some customers and blog readers asking me if they should go for NW.js or if they should go direction Electron. There is no quick answer to this question. It’s this kind of question that has to be answered with It depends.

I’ve used both frameworks for real projects in the past, and both of them worked great for the given projects. Neither Electron nor NW.js is perfect (but they’re close to it) 😃. Each has its pitfalls. However, the communities behind those frameworks are fantastic and keep on answering quickly to questions popping up on GitHub or in tools like Gitter or Slack.

Pug-up your Angular markup

Fri, 05 Feb 2016 00:00:00 +0000

Can you imagine the combination of Angular and Pug (previously known as Jade) is super awesome and timesaving? If not, read the following lines and reconsider!

When building SPAs using Angular or AngularJS, you use custom HTML markup extensions (aka directives) to instrument Angular how to render your SPA or how the different building blocks of your app should correspond to user interaction. Using those directives is smooth and well known in the Angular Community.

Be more productive with Pug

Thu, 04 Feb 2016 00:00:00 +0000

Pug (previously known as Jade) is like HTML on steroids. Once learned, you’ll never miss it. This article isn’t my first post on Pug. I had already written an article about it back in 2013 when it still was called Jade. If you didn’t read it yet, take your time, go and read through the Pug introduction.

This post covers only a few but powerful features Pug is offering to make you a more productive frontend developer.

Angular Quickie — ViewEncapsulation.Native in all browsers

Wed, 03 Feb 2016 00:00:00 +0000

A few days ago I wrote about Angular ViewEncapsulation. The sample I’ve created for that post only works if you’re using Google Chrome. In this article, I’ll explain why the sample only works in Google Chrome and how you can take the example one step further to work and behave as expected in all modern browsers.

Angular is using ViewEncapsulation.Emulated by default, to render components. Emulated means you’re not using native ShadowDOM features; instead Angular does some refactoring to both, your template and your styles, to encapsulate those from the rest of your app and render everything as expected. (see the linked article above for more details).

Testing Angular Apps with Jasmine and TypeScript

Mon, 01 Feb 2016 00:00:00 +0000

Unit-Testing Angular applications made me crazy during Beta time. In this post, I’ll share how to set up unit testing for Angular applications. The samples below were tested on Angular 2 Beta 2 and Beta 3. There are many resources available on the web that explain how unit-testing should work in Angular beta. Unfortunately, none of them worked for me from front to end. The official documentation is also lacking a fully working example with SystemJS while I’m writing this article. Things may change over time, so you should check out the latest documentation on https://angular.io.

Setting Electron App-Icons for Windows from macOS

Sat, 16 Jan 2016 00:00:00 +0000

When building cross-platform apps using GitHub Electron, you may run into the same issue I did a few days ago. I wanted to build an Electron app for Windows and macOS directly from my host-system (also macOS). The build-process failed because setting the Windows App Icon didn’t work for me when building it from the Mac.

I was using gulp-atom-electron to build the apps automatically. It has a dependency on rcedit which is a small Windows executable that is responsible for updating either Windows Assemblies or Windows Executables to make resource changes from outside. GitHub itself has published a corresponding npm module which uses wine to execute wine rcedit app-name.exe --set-icon app-icon.ico if you’re executing the code on a macOS or Linux system.

Angular Quickie - Component ViewEncapsulation and WebComponents

Fri, 08 Jan 2016 00:00:00 +0000

“Component” is perhaps the most overloaded term when it comes to JavaScript frameworks these days. Every single framework has its definition of what precisely a component is, also Angular.

Components are the building blocks of Angular apps. By default, Angular embeds components into the DOM. When Angular renders your component, the entire contents of your template (string or loaded from the given URL) goes inbetween the component’s selector.

There are two different ways how Angular is injecting the view for a given component. ViewEncapsulation is responsible for defining how Views are injected. If you create a component like this:

Angular Quickie - Local template variables

Thu, 07 Jan 2016 00:00:00 +0000

Local template variables in Angular can be used to reference HTML elements easily and use their properties either on sibling or child nodes.

It’s pretty easy to create and use those local template variables. Let’s say you have got an input file for dealing the first name of someone.

<input type="text" placeholder="your name please" required maxlength="25" />

You can make the HTMLInputField available to sibling or child nodes using the # symbol.

<input type="text" #firstName placeholder="your name please" required />

Next, let’s say we want to extend our small example to provide a char counter beside the element. Users will see how many characters are available until they hit the maximal length constraint. First, let’s add the corresponding span which is responsible for displaying this information.

Angular Quickie — Elvis is in tha house

Thu, 07 Jan 2016 00:00:00 +0000

Another Angular quickie for today!😉 Angular introduces the Elvis operator ?. is used in templates.

CoffeeScript Developers may know this as “Existential Operator” which can easily be used to check if a variable has a value.In combination with *ngFor and *ngIf this makes a good toolbelt for rapidly building UIs within *Angular *Apps.

The official Angular documentation gives you a few examples of how to use the Elvis operator.

Angular Quickie — How to structure your projects

Thu, 07 Jan 2016 00:00:00 +0000

When building large Angular Apps, you’ve to care about how to structure your project. I can imagine, John Papa will, of course, provide a new style guide soon 🙂 (no pressure here, we’ve our own for Angular.JS and Angular).

But already in those early days, you’ve to care about the project structure. Refactoring an entire project structure is hard 💩. So think about it, before you start coding.

Building an electron app using Angular Beta0 in TypeScript

Thu, 07 Jan 2016 00:00:00 +0000

You can build Angular apps using plain old JavaScript and TypeScript. I’ve been using plain JavaScript for the past Angular demonstrations, because I felt in love again with JavaScript after spending years with CoffeeScript (But that’s a different story). However, teams at Google and Microsoft were working together in these days to marriage Angular and TypeScript. If you don’t know TypeScript yet, go and learn it. It will change the way how you write Frontend stuff in the upcoming years. You can think of it as todays *JavaScript on steroids. It makes you more productive, it makes your code more robust, you’ve to write less plumbing because the TypeScript Compiler (TSC) generates all the good parts of JavaScript and knows about the edge-cases.

Angular goes cross platform with GitHub Electron

Mon, 16 Nov 2015 00:00:00 +0000

A while ago I’ve posted a sample on how to write an electron app using Angular 1.x with ES2015 and JSPM.

Now having more than 100 stars on GitHub, it seems to be quiet important for the community. That’s why I’ve decided to take this sample to another level.

Angular2 is becoming more severe with each day. That’s why I’ve decided to publish another electron sample targeting Angular2. Go and visit the repo right here on GitHub

Frontend Builds 7 - Conditional Build Tasks

Sat, 24 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the seventh and last part of this article series. If you didn’t read the other parts, check them out now.

Idea

During the last post, we made our BaaS configurable so that you can align the build to work with different folder structures, filenames or module configurations. Now it’s time to take our build to another level. Many developers are using things like less, Sass to build their stylesheets. Others use CoffeeScript, BabelJS or TypeScript to build their JavaScript. Exactly those tasks are missing in our BaaS solution, so let’s add them.

Frontend Builds 6 - Configurable builds

Thu, 22 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the sixth part of this article series. If you didn’t read the other parts, check them out now.

Idea

BaaS is fine so far if you’re building your projects on the same structure I did for building x-note. However, right now, we’re using Build as a Service, so it’s time to make everything configurable.

Frontend Builds 5 - Build as a Service (BaaS)

Wed, 21 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the fifth part of this article series. If you didn’t read the other parts, check them out now.

The idea

Most developers frequently create new projects, either for work or for just trying something new. This is also true for me. I found myself using yeoman to create new projects almost every day automatically. There are plenty of great generators available in the wild. Just visit the yeoman website and discover the generator repository, it’s fantastic.

Frontend Builds 4 - Building Cross Platform Mobile Apps

Sat, 17 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the fourth part of this article series. If you didn’t read the other parts, check them out now.

The Idea

During this post, I’ll explain how to bring x-note to various mobile platforms using Apache Cordova. x-note has been built using Angular Material, so it can easily fit on any resolution no matter if customers are using a 27" Cinema Display or a 5" cellphone. We’ll extend our build process to build and run mobile apps automatically.

Frontend Builds 3 - Cross Platform Desktop Builds

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

The Frontend Builds article series

Welcome to the third part of this article series. If you didn’t read the other parts, check them out now.

The idea

Frontend Apps can quickly be built for a various range of platforms. You can use Apache Crodova for building cross-platform mobile apps. For building cross-platform desktop apps, you can either use Electron or NW.js.

Frontend Builds 2 - readable and pluggable Gulp files

Wed, 14 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the second part of this article series. If you didn’t read the other parts, check them out now.

The idea

Within this post, I will explain the steps I used to move from the initial gulpfile to a readable and more maintainable version. Before explaining the technical steps, let’s talk about the target. Over the past year I’ve seen so many different styles and approaches for writing and organizing Gulpfiles, but most of them share the same problem. Once you revisit the project and its gulpfile after a few weeks or months, you need much time for reading and understanding what gulp is doing in this particular project when executing gulp default or just gulp. To reduce this effort, I’ve outlined my idea of how to align tasks and how things should interact using a small mockup

Frontend Builds 1 - Getting started

Mon, 12 Oct 2015 00:00:00 +0000

The Frontend Builds article series

Welcome to the very first part of this article series. If you didn’t read the other parts, check them out now.

Idea

As described during the introduction, here the link to the sample frontend application. x-note is a small note-taking application which I’ll use for this series of posts. I’ve build the app using AngularJS and angular-material.

Frontend build series introduction

Thu, 08 Oct 2015 00:00:00 +0000

Here at Thinktecture, we’re focusing on cross-platform apps, and we’re optimizing our development workflow continuously to push boundaries when it comes to development performance. I found myself again falling in love with creating fast and super awesome build processes. I want to use today’s lunchtime to write this short introduction post. So in the upcoming weeks, I’ll share some cool things around cross-platform builds. If you haven’t heard of Gulp.js, it could be a bit difficult to follow the series because I will not publish an introduction for Gulp.js. Do some research on Gulp.js to understand the critical concepts of Gulp.js.

Chromebook review / Chrome App Model

Fri, 14 Aug 2015 00:00:00 +0000

Today I received my Acer C720P Touch Chromebook. I’ve used it now for around about two hours. It is a stunning device, double check the price on Amazon it’s about $280 (199€ in Germany) Amazon Deeplink!

Some technical details

Intel Celeron Processor 2955U
2 Gigs of RAM
16 Gigs SSD
11.6” Screen @ 1366×768 pixels
TouchScreen
Multi-Gesture TouchPad
7.5 hrs Battery Lifetime

First Impressions

As you can see in the picture below, the device looks pretty good, and you may recognize the glossy display. The keyboard is good for programming, but it’s a bit small for my hands.

On the move — Goodbye SharePoint

Fri, 29 May 2015 00:00:00 +0000

After more than seven years of doing SharePoint Development I will leave the SharePoint Business by today and start a new journey.

Over the past years, I was involved in numerous SharePoint projects from a developer’s and a consultant’s perspective. It has been a blast.

For those of you that know me in person, this is not so surprising. Over the years I’ve always tried to bring the latest and greatest technologies, frameworks and even other programming languages into SharePoint to have more fun during daily business.

Automate everything — A journey from GitHub over Codeship to Docker on Azure

Thu, 21 May 2015 00:00:00 +0000

Do you want to go from code to (pre)production in a few seconds? No problem. I’ve used the last night to get that working. I want to share the journey with you guys right here.

There are several services involved, but the glue between those services are a set of good old shell scripts 🙂 So, unfortunately, no introduction for services like

GitHub
Codeship
Microsoft Azure
Docker

If you don’t know those things go for google. There are tons of introductions for each of those.

Setting up iTerm2 with OH-MY-ZSH and Powerline on OSX

Thu, 07 May 2015 00:00:00 +0000

When people ask me why I’m using a Mac instead of a Windows device for doing all my stuff, I always end up with a single but significant reason: I have a real shell! Most hardcore Windows fans are answering to this comment: “Well there is PowerShell” or: “Hey we have Cygwin” but to be honest, those are no alternatives to a real shell 🙂

A few people asked me over the time which configuration/theme and stuff I use within my terminal and because I’ve to set up a new device in these days (a stunning brand new 13" MBP Retina with ForceTouch)

When Electron's window.setTitle keeps you driving crazy

Wed, 06 May 2015 00:00:00 +0000

As a reaction on my initial post about Electron, Ingo Richter came up with a comment on setting the window’s title. He described that he get errors when trying to set the window title to the app’s name.

browser-window is exposing the setTitle function and app is exposing the getName function. So my first impression was “well, that should be easy to realize”, but there is on common pitfall that I realized when trying to set the title of the window – which I’d like to share with you.

Packaging Electron apps as ASAR archive using Gulp.js

Tue, 05 May 2015 00:00:00 +0000

A couple of weeks ago I open-sourced a sample on how to build an electron app using Angular and ES6. The sample has become popular on Github, so I sat down and updated the sample a bit. All changes are about distributing the electron app.

https://github.com/ThorstenHans/electron-angular-es6

Instead of writing down all the bits, I’ve started Camtasia and recorded a short webcast.

I’ll explain all the required steps from 0 to the final app.asar package in these 11 minutes. Enjoy

Writing an Electron app using Angular and ES6

Mon, 04 May 2015 00:00:00 +0000

If you haven’t heard of Electron (formerly known as Atom Shell) you should check out it’s official website here.

In this post, I will not provide an introduction for all the different tools and frameworks. It’s more a walkthrough that should give you some hints on how to get things up and to run with the following stack.

Electron
Angular.JS
ES6 using Babel as transpiler
SystemJS as module-loader

Getting started

First of all, you’ve to ensure that all dependencies are installed on your system and a simple folder structure has been created for the sample project.

About

Fri, 03 Apr 2015 02:13:50 +0000

Hello, my name is Thorsten, and I live in Saarland — the most beautiful state of Germany. I work as a Senior Developer Advocate at Akamai, where I help developers build high-performance, distributed systems for the edge.

Hello 👋🏼

I’m a Docker Captain and a WebAssembly enthusiast who thrives on pushing the limits of WebAssembly and Edge Computing. These days I focus on cloud-native and serverless application architectures built with containers and WebAssembly — contributing to projects like Spin and SpinKube. Before that, I spent years deep in Kubernetes and Infrastructure as Code, especially Terraform.

Managing Node.js and io.js with NVM

Mon, 23 Feb 2015 00:00:00 +0000

Are you building Node.js Apps? Use NVM!

If you haven’t seen NVM (Node Version Manager) in action, go and install it now. I can’t imagine working with Node.js based projects without NVM. I wrote this short post because I saw a friend of mine doing some first steps in Node.js without having NVM installed. So instead of explaining him the basics on a phone call, I wrote this summary, which I’d like to share with you.

Developer presentations using reveal.js

Thu, 19 Feb 2015 00:00:00 +0000

reveal.js has been around for a while. I saw many people using it for their presentations (for example AC). AC also wrote a great article on how he is organizing his presentations on GitHub using reveal.js.

AC’s idea is cool, but I wanted something more something which is less pain, I don’t want to set up a gh-pages branch on every repo I create for my demos.

Instead, I built a presentation hub using reveal.js and some simple Gulp.js tasks.

I ❤ CodeShip

Mon, 26 Jan 2015 00:00:00 +0000

Within this post, I’d like to give you a short introduction for using CodeShip to automatically build, test and deploy your web projects.

CodeShip is a service which is free for a single concurrent build with 100 builds per month. So there is no cost for giving it a try, if you’re interested in bigger plans with more concurrent builds or if you (and your team) are more frequently pushing commits to either GitHub or BitBucket you can choose one of the available paid plans from here.

ASP.NET vNext on OSX Yosemite — Get KVM up and running

Thu, 13 Nov 2014 00:00:00 +0000

I use .NET for building WebAPI’s because all other stuff is mostly done using AngularJS and Node.js in these days. However, since the incredible change that Microsoft is living these days, I can finally get rid of my virtual development machine 🙂

To get ASP.NET vNext up and running on your Mac, you’ve of course to use Mono. In the case you’ve already installed Xamarin on your system, you may run into the issue that your Mono version is outdated.

Accessing an WebAPI using ADAL.JS and Azure AD within AngularJS

Wed, 12 Nov 2014 00:00:00 +0000

Building a secured WebAPI using Azure Active Directory (AAD) is pretty easy, OWIN middleware allows developers to integrate AuthN in their services quickly.

Accessing those API with plain old C# is easy because AAD Authentication Library (ADAL) for .NET is available for quite a long time (at least what we call a long time in our business :D)

During TechEd Europe, Microsoft announced and released the developer preview for ADAL.js — a lightweight JavaScript library for integrating AAD authentication into your Single Page Application (SPA).

O365 API — The ultimative list of resources for devs

Fri, 31 Oct 2014 00:00:00 +0000

Finding information targeting the latest Office 365 API builds can be a hard job, that’s why Chaks - he’s one of the Program Managers at Microsoft who’s currently working on the O365 API Tools — has summarized an impressive list with all critical resources.

If you’re new to Office365 development and don’t know where to get started, I advise you to read at least this post http://chakkaradeep.com/index.php/the-ultimate-link-roll-for-getting-started-with-office-365-apis

On top of that, he’s frequently blogging great articles on O365 and sharing examples on those APIs.

Office 365 API Tools — GA Release changes

Wed, 29 Oct 2014 00:00:00 +0000

Yesterday I only posted a short post about the most recent release of Office 365 API Tools.

I had the chance to get some hands-on since yesterday and the most important thing you’ll see when using the GA Release maybe, that there is no longer a CalendarApiSample, MailApiSample or similar sample class for accessing resources from Office 365.

There are some reasons why those samples are gone, but for developers starting with Office 365, it’s a little bit harder right now to get started.

Office 365 API Tools Update

Tue, 28 Oct 2014 00:00:00 +0000

The Office 365 API Team released a new version of Office 365 API Tools today. The new release can be downloaded directly from Visual Studio Gallery right here or by using Visual Studio’s Extension Manager Window.

With this version, the Tools are official out of preview.

ShareCoffee 0.1.3

Fri, 03 Oct 2014 00:00:00 +0000

ShareCoffee 0.1.3 is available by now on NuGet and bower. It’s only a small release at this time. Previously I’ve added ShareCoffee.Commons.infect() to ShareCoffee as described here.

With 0.1.3 this method got an optional parameter which is very useful for SharePoint Hosted Apps. If you built a SharePoint Hosted App using a plain HTML or ASPX Page, you’ve also to maintain all a and form tags and ensure that SPHostUrl is part of the QueryString.

ShareCoffee 0.1.2

Sat, 27 Sep 2014 00:00:00 +0000

A while ago I wrote about SharePoint Apps in ASP.NET MVC and how to get them working.

With ShareCoffee 0.1.2 — which is already available on NuGet and bower — you can now ensure that SPHostUrl is appended to all links in your Apps without making changes to spcontext.js which is provided by Microsoft.

You can now remove the OOB bundle config and references to spcontext.js from your Apps and use a single function to extend all links and forms by directly calling

grunt-nuget - Create NuGet packages on macOS and Linux

Wed, 24 Sep 2014 00:00:00 +0000

While building ShareCoffee, I recognized that building NuGet packages doesn’t work on macOS or Linux. Today I’d the chance to look again into this issue.

I’ve used grunt-nuget for building the NuGet packages for ShareCoffee from within my GruntJS tasks.

Responsible for the fact that I wasn’t able to create the NuGet packages on MacOS or Linux was the .nuspec file. To build NuGet packages on other operating systems than Windows systems, you’ve to use Unix paths instead of Windows paths.

Use 'bower install' on Heroku

Wed, 24 Sep 2014 00:00:00 +0000

bower.io is a fantastic tool for managing client-side dependencies. When you’re deploying a Node.js app to Heroku, you’ve to add script to your package.json file instead to get bower running right after installing your app using git.

First, you’ve to ensure that bower is part of your dependencies. Either double-check the dependencies object within your package.json or execute

npm install bower --save

Somewhere in your package.json you’ll find another object called scripts add a dedicated script for postinstall like shown in the following snippet:

Slides and Samples from CodeCamp NYC

Tue, 16 Sep 2014 00:00:00 +0000

On Saturday I spoke at CodeCamp in New York. It has been the third CodeCamp NYC in a row for me. I like the community event in New York because I’m able to combine both, holding a session and visiting one of the greatest cities in the states.

Finally, I got a talk which wasn’t related to SharePoint 🙂 “ASP.NET MVC ❤ AngularJS.”

Most of the tips and hints I gave during this talk came from real-world customer projects which were built using that technology stack with only a few SharePoint integration points 🙂 So I could focus on the Angular and MVC WebAPI stuff.

ShareCoffee eBook

Fri, 29 Aug 2014 00:00:00 +0000

About a week ago I finally published my first eBook on LeanPub.

The book covers all the different ShareCoffee features and describes how to use them within SharePoint App projects. On about 100 pages all the different capabilities are explained and demonstrated using small code-snippets.

There is also a short SharePoint App introduction included if you’re not familiar with the SharePoint App platform. Leanpub is offering a flexible pricing model. So usually the minimal price for my eBook is $9.99 but based on a two-week poll the suggested price has been locked at $10.99 (but it’s entirely up to you how much you spend).

ShareCoffee with JsonLight support

Mon, 25 Aug 2014 00:00:00 +0000

A few minutes ago, I published the version 0.1.1 of ShareCoffee.

It’s available on NuGet and bower.io for downloading and upgrading if you’re already using it. New in the current release is JsonLight support for Office365. If you’re running on demand, your tenant can produce different results when calling SharePoint’s REST services.

On August 13th, Microsoft announced the availability of JSON Light responses for Office 365 on its Office blog right here.

From the field: Ensure SharePoint Context for all kinds of redirects in MVC

Sun, 01 Jun 2014 00:00:00 +0000

During the last months, I was responsible for building a huge Provider-Hosted SharePoint App. During this journey, I’ve used the latest version of ASP.NET MVC and Entity Framework to build a beautiful, scalable and clean Web Application to fit customer’s requirements.

When building SharePoint Apps using Visual Studio, a NuGet Package is installed which is also responsible for including spcontext.js into your Web-App’s script folder.

This small part of JavaScript is critical. It’s responsible for concatenating SharePoint’s HostUrl QueryString Parameter to each link tag sitting in your Web-App. By concatenating this QueryString parameter, we can create a SharePointContext from within the Controller sitting behind the route that catches the target of the Hyperlink.

Implementing CRUD with Office365 APIs

Sun, 01 Jun 2014 00:00:00 +0000

Office365 API’s current preview version can generate some sample code for you. However, the sample only contains code for reading data. People from the community asked me how they can write entities back to Office365, and that’s why I want to share the following sample, which explains to you how to implement all CRUD methods using Office365 API.

I hope this post makes clear, that Office365 is supporting the full CRUD stack, no matter which kind of entity (Contacts, Calendar Events, Users, Groups, Mails, Files) you’re interested in!

Our SharePoint Power Hour from TechEd North America

Mon, 19 May 2014 00:00:00 +0000

Last week I was attending Microsoft’s TechEd North America in Houston Texas. Together with Jeremy Thake who has recently moved over to Redmond to work with the Microsoft Office Division (MOD) at Microsoft Corp, we’ve delivered the SharePoint Power Hour. Some of you guys may already know this Session Topic from Build conference.

However, compared Rob Howard’s version from Build 2014, Jeremy and I decided to go for the most recent release of Office 365 API’s which have been shipped last Monday during TechEd Keynote.

Proper Paging Implementation for Office365 APIs

Mon, 19 May 2014 00:00:00 +0000

I’m currently working on another (fancier) sample for using Office365 APIs from Web Applications. During today’s night session I tried to implement the entire Service and Repository for my sample. I started with the current sample API implementation from Office 365 API Tools I made a lot of changes to this to provide even more features and to be more efficient as the current static class sample.

During this post, I’d like to show only the GetContacts method which has been refactored a little bit to provide real paging support for my contacts sitting in Exchange Online.

Building an Office365 development machine using Microsoft Azure VirtualMachines in no time

Tue, 13 May 2014 00:00:00 +0000

Today Microsoft announced the availability of client machines in Microsoft Azure. It turns out to be an excellent deal for Office365 Developers too. By just creating a new Machine (let’s take a Windows 8.1 including Visual Studio 2013 Update 2 for example) you can quickly spin off an Office365 development machine in no time.

When logged in to the Azure Portal, you’ve to navigate to Virtual Machines and select New and pick an Image from the Gallery

Using Office365 API's in MVC WebApps

Tue, 13 May 2014 00:00:00 +0000

Yesterday a new version of Office365 API Tools Preview had been shipped. Many things have changed with the latest release. I’ll not write all the new features and changes down manually, instead I’ll explain how to write an MVC WebApp which calls into Office365 and pulls out upcoming events from Exchange Online for the given user.

Before you start

Ensure that you’ve installed the latest Version of Office365 API Tools Preview you can either download the bits from dev.office.com or install/update it directly from within Visual Studio 2013 using the Extensions and Updates window.

Create a lightweight REST service using Sinatra

Mon, 28 Apr 2014 00:00:00 +0000

Exposing data using a REST service is an easy task which can be achieved using almost any programming language. In the past, I’ve used ASP.NET MVC WebApi to achieve this.

However, as soon as you’ve to run your service on different platforms, CLR isn’t the best option. Programming languages like Ruby and Python or Node.js are stronger when it comes to cross-platform support.

I love the Ruby syntax, and that’s why I’ll show how to build a small REST Service exposing tasks using Ruby’s Sinatra framework. Sinatra doesn’t require a fix or predefined project structure. I want to organize all the artifacts a little bit. That’s why I’ve chosen the following structure

Easy switching between yammer accounts

Tue, 22 Apr 2014 00:00:00 +0000

Yammer is organized within different networks, which is excellent as long as you’re invited with a single mail address. As soon as you accept an invitation for a second email address you’ve to explicitly log out with the first mail address and re-login with the second one.

Yammer is currently not offering a mechanism to merge or link two accounts.

Most Yammer users are using different browsers to deal with this problem. However, that wasn’t a solution for me. I’ve configured Chrome to fit my needs, provide all my bookmarks in a single place and I won’t lose this experience because of the missing ‘merge my accounts feature’ in Yammer.

MVP Mentor Session: Building SharePoint Apps with JavaScript

Tue, 22 Apr 2014 00:00:00 +0000

The Microsoft MVP Mentor Program is offering free learning resources for students presented or created by Microsoft MVPs. Yesterday I’d the chance to do a webinar on SharePoint App Development using JavaScript.

The webinar was in German, but I’ve created the slides in English to provide a value for a broader audience. If you’re interested in a rough introduction into building SharePoint Apps check out my slide deck.

I’m currently trying to manage the second run of this webinar in English. As soon as the recording of my session is available on Youtube, I’ll update this post and also embed the recording itself. As mentioned earlier, this is an introductory session which will explain to you the very basics of building Apps for SharePoint using client-side technologies and call into SharePoint’s APIs (CSOM and REST).

Top 25 European SharePoint Influencers

Mon, 31 Mar 2014 00:00:00 +0000

Harmon.ie is again looking for the Top 25 European SharePoint Influencers. Again as back in 2013 the winners are announced during European SharePoint Conferences (which takes place in May 2014 in Barcelona).

Contribute

So please invest two minutes and vote for me at http://www.scratchmm.com/sharepoint-eu/community-vote/

Thank you, Community!

Dell Venue 8 Pro Review

Wed, 26 Mar 2014 00:00:00 +0000

During SharePoint Conference 2014 in Las Vegas, I bought a Dell Venue 8 Pro because I was looking for a small device in addition to my Surface Pro and my 15” MacBook Pro.

Here my most essential requirements

Long battery lifetime
Running Windows 8 Pro
Having access to all my essential services like — Multiple Exchange Accounts
OneDrive
OneDrive for Business
Windows Azure
The device should be rechargeable easily

At this point, I’d like to say thank you to my good old friend Heino, who pointed me to Dell’s device and gave me the chance to play a little bit with his Venue 8 Pro during SPC14.

Slides and Demos from my SPC14 talk on ShareCoffee

Wed, 19 Mar 2014 00:00:00 +0000

As every year, SPC14 was a blast. It was amazing to connect with all the guys and girls from the SharePoint world. During this post, I’m not going to summarize the SPC, so this post is only providing the content from my talk (#SPC417). First and most important are the demos.

Demos

All my demos are available for free on GitHub, so go and check out https://github.com/ThorstenHans/SPC417, regarding ShareCoffee in common, you should check out the ShareCoffee landing page at https://sharecoffee.github.io

ShareCoffee 0.0.11

Tue, 25 Feb 2014 00:00:00 +0000

Over the last weeks, I’ve added some new features to ShareCoffee which are now available in the most recent release.

As for all previous versions you can grab a copy using NuGet or Bower.IO.

New Shorthand for ShareCoffee

To save even more keystrokes when building Apps for SharePoint, you can access ShareCoffee now by using the $s shorthand.

Inject custom AppWebUrl

Since the first release of ShareCoffee, you’re able to load AppWebUrl by providing a custom function. With the release of 0.0.11, you’re also able to load the AppWebUrl by yourself and provide the actual string to ShareCoffee.

SharePoint.Jasmine — Test your JavaScript directly inside your App

Tue, 25 Feb 2014 00:00:00 +0000

Today I’ve published SharePoint.Jasmine on GitHub and NuGet which allows you to test your JavaScript code directly inside of a SharePoint App. By installing SharePoint.Jasmine into your project using

Install-Package SharePoint.Jasmine

All required artifacts for executing JavaScript UnitTests using Jasmine are automatically integrated into your App project. The updated App structure will look like the following

Most important is the actual test page located in Pages/tests

The index.aspx file is responsible for loading the Jasmine Test-Runner, the specs and all the JavaScript source files you’re interested in. By default, I’ve added the Jasmine-Sample folder which gives you a rough introduction in how to write JavaScript unit tests using Jasmine. When installing the App and navigating to the Test-Runner-Site, you’ll receive the test results embedded in the default SharePoint MasterPage.

The ShareCoffee logo

Sat, 22 Feb 2014 00:00:00 +0000

I’m glad to present the new ShareCoffee logo.

A big thank you to Oliver Jungmann for creating the awesome logo. A big thank you to Stefan Hübsch for providing his awesome new font Typocalypse Lichtspiele.

For me as a developer, it’s always amazing to see people creating such logos in almost no time. Creativity is just awesome.

For all the SharePoint Conference attendees out there, Hopefully, the ShareCoffee stickers are shipped before #SPC14. Come and visit my #SPC417 session and grab some of those cool stickers.

ShareCoffee.UserProfiles is available

Fri, 21 Feb 2014 00:00:00 +0000

Today I’ve published the next AddOn for ShareCoffee. ShareCoffee.UserProfiles. It’s providing a dedicated wrapper for SharePoint’s UserProfiles API.

By using the new AddOn, you can easily configure REST requests for dealing with SharePoint’s UserProfile REST API from both, SharePoint Hosted and Cloud-Hosted Apps.

Installation

You can install the AddOn (which will automatically pull ShareCoffee as a dependency) by using.

NuGet
bower.io

Coverage

Not all UserProfile methods are currently available as REST endpoint. Currently, SharePoint is offering the following methods which can, of course, be used with ShareCoffee

An Introduction to SASS

Tue, 18 Feb 2014 00:00:00 +0000

Throughout this post, I’ll give you a rough introduction into SASS as part of my branding SharePoint sites with yeoman series. See all other posts from this series here.

SASS

SASS (Syntactically Awesome StyleSheets) is a language which compiles into CSS and allows you to write your styles in a comfortable and use all the cool things which CSS is missing like variables, mixins or nested rules.

An Introduction to CoffeeScript

Fri, 14 Feb 2014 00:00:00 +0000

A while ago I started a series about how to brand SharePoint sites using the Yeoman web development workflow. With this small introduction to CoffeeScript, I’d like to continue the series.

CoffeeScript is a small language that compiles into JavaScript. The initial release of CoffeeScript was published back in 2009. Since then the language has become more and more popular. The CoffeeScript source code is hosted on GitHub, and there is an excellent website (coffescript.org) which teaches you all the things you’ve to know about the language.

ShareCamp 2014 in Munich

Fri, 31 Jan 2014 00:00:00 +0000

In 2014 we will celebrate the 5th ShareCamp in Munich. (23rd — 25th of May 2014) Don’t panic; the registration isn’t opened yet. However, you should check out our new website at born2share.com and get the latest information about the event.

I’m thrilled to say that we’ll again be able to host the ShareCamp for 200 attendees! Moreover, it’s all for free.

An entire weekend full of SharePoint.

Write your own ShareCoffee AddOns using the yeoman generator

Fri, 31 Jan 2014 00:00:00 +0000

Today I’ve published a new yeoman generator which allows you to create new ShareCoffee Add-Ons easily. (view on GitHub) If you haven’t heard of Yeoman, you should check out its website at yeoman.io.

By using such a yeoman generator, you can start building web-apps or –in this case– ShareCoffee Add-Ons in no time.

Moreover, the best advantage is: All these frameworks and tools are based on Node.js and can be used from any platform running Node.js. (Also a low budget Chromebook can run Node.js).

CoffeeScript vs TypeScript vs JavaScript — my thoughts

Wed, 29 Jan 2014 00:00:00 +0000

Throughout this post, I’d like to share my thoughts on Coffee-, Type- and JavaScript, because many people from the community were asking me for which language they should go or why I’ve chosen CoffeeScript for writing my SharePoint framework ShareCoffee. First of all, I’ve been doing JavaScript for a long, long time. I’ve spent much time reading books on how to write JavaScript code and how to do it well. Here, for example, two (in my opinion essential) books for JavaScript Developers, independent from their skill.

Query FormDigestValue from SharePoint using ShareCoffee

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

When running in a SharePoint-Hosted App, you can easily receive the FormDigestValue by executing ShareCoffee.Commons.getFormDigest() which is very easy.

However, if you’re executing queries from a plain HTML page sitting in your SharePoint-Hosted App - or in the case, you’re running in an Office Add-In - you can ask for a FormDigestValue using ShareCoffee’s REST interface. The following sample code shows how to receive the FormDigestValue from within a plain HTML Page using AngularJS.

ShareCoffee.Search is available

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

I’m glad to announce the availability of ShareCoffee.Search GitHub 0.0.1.

Today I’ve published the first Add-On for ShareCoffee. By using ShareCoffee.Search (which is also available on NuGet, bower.io, and GitHub) you can now easily execute Search queries from any SharePoint App. ShareCoffee.Search offers a fully configured PropertyObjects to support you by writing any search query. Of course, can you use ShareCoffee to execute a GET or POST request against SharePoint’s Search API but then you’ve to remember all of the property names, which turned out to be very time-consuming. That’s why I decided to publish this Add-On.

Using SharePoint 2013 Search REST API to execute PostQueries

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

Because I’m currently writing my first Add-On for ShareCoffee which is going to provide a fluent and easy way to consume SharePoint’s Search Services, I had to dig a little bit deeper into SharePoint Search REST API.

Executing Search requests as a GET request is straight forward, and there is nothing special about them. However, if you hit the URL length limitation of your browser you should consider executing the search query using SharePoint’s PostQuery endpoint. (/_api/search/postQuery).

SPC417 Session Trailer

Sat, 25 Jan 2014 00:00:00 +0000

Like all other SharePoint Conference Speakers, I’ve also published a short trailer to promote my ShareCoffee session at SharePoint Conference 2014 in Las Vegas.

Watch it on youtube, and I hope you’ll join my talk in Vegas 🤘🏼

What's new in ShareCoffee 0.0.8

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

Today I’ve published ShareCoffee 0.0.8. You can download the latest version from GitHub or directly include the library into your project by using NuGet or bower.io.

What’s new in this release

Version 0.0.8 of ShareCoffee ships with some great new features. I’ve added full API documentation which is hosted directly on GitHub (see the docs folder) or have a look at the .coffee sources. I’ve also removed the classes ShareCoffee.REST.angularProperties, ShareCoffee.REST.jQueryProperties and ShareCoffee.REST.reqwestProperties. Instead, a unified, new class called ShareCoffee.REST.RequestProperties was added.

Visualise your data with ShareCoffee and ChartJS

Fri, 20 Dec 2013 00:00:00 +0000

Visualizing data in SharePoint Apps is easy if you combine ShareCoffee and ChartJS.org. ChartJS.org is a small JavaScript library which is responsible for rendering HTML5 charts in websites.

Creating a sample App

For this post, I’ve prepared a small SharePoint list containing EnergyDrinks and their amount of caffeine. 🙂 To read the data from SharePoint, you need to include and reference ShareCoffee. Using Visual Studio’s Package Manager Console you can install ShareCoffee using Install-Package ShareCoffee Including ChartJS.org is also really easy, grab the Chart.js file from GitHub or the project site chartjs.org.

Loading the App ChromeControl with ShareCoffee

Fri, 13 Dec 2013 00:00:00 +0000

ShareCoffee assists you as a SharePoint App Developer in various situations. Of course is the most significant benefit the unified REST layer across all different kinds of SharePoint Apps and query targets (AppWeb / HostWeb).

But there are some other nice features backed into ShareCoffee. Within this post I’ll explain how to load SharePoint’s ChromeControl and CSS within Cloud-Hosted-Apps. First, it’s important to mention that ShareCoffee does not require any other JavaScript library. It’s no problem if you’re using jQuery or similar libraries, but you don’t have to. Instead of following the MSDN and writing about 40 lines of JavaScript code to get the ChromeControl into your app, ShareCoffee exposes a single function which has to be called to achieve the goal. First, you’ve to install ShareCoffee within your App. ShareCoffee can be installed in various ways.

Speaking at SharePoint Conference 2014 in Vegas

Thu, 05 Dec 2013 00:00:00 +0000

The biggest and best conference about SharePoint, Microsoft’s SharePoint Conference takes again place in Las Vegas from 3rd till 6th of March 2014. I’m glad to announce that Experts Inside delivers two sessions next year in Vegas.

To see the entire list of session check out the #SPC14 website at http://www.sharepointconference.com/content/sessions Within an in-depth dive developer session I’ll explain how to speed up your App Development for SharePoint using API abstractions. In detail, I’ll show the benefits of my Open-Source-Framework ShareCoffee and how you can take the best benefits from using such frameworks.

Creating an ExcelServices JavaScript UDF — A working Sample

Mon, 11 Nov 2013 00:00:00 +0000

Excel Services in SharePoint 2013 is offering some new functionalities. One of these is a JavaScript User Defined Actions (UDFs). There is currently one a little documentation on MSDN covering this topic. The given MSDN sample contains a small example which didn’t work at all. Because a customer would like to see the new features Excel Services are offering in 2013 (including Office 365). I had the choice to discover this feature by myself 🙂.

ShareCoffee is available

Tue, 29 Oct 2013 00:00:00 +0000

I’ve published ShareCoffee today on GitHub. ShareCoffee is a small library containing cool stuff for SharePoint App developers. ShareCoffee is entirely written in CoffeeScript using the test-driven-design approach with (Mocha, ChaiJS, and SinonJS). Since the SharePoint App model is available, I thought about writing this library, but within the last four days I sat down and created it! 🙂

ShareCoffee is offering all the stuff I was faced with since I started App development for SharePoint. The goal was for me to create a library which provides a single programming interface for any SharePoint App. What is ShareCoffee offering ShareCoffee is offering various functionality which I’ve grouped into the following namespaces:

An Introduction to Pug (aka Jade)

Tue, 22 Oct 2013 00:00:00 +0000

‘An Introduction to Pug’ is part of my article series ‘Branding SharePoint sites with yeoman’ see the list of all related articles here.

Why Pug (aka Jade)?

Well, HTML MasterPages and PageLayouts are great, and this is precisely what we’re going to create, but instead of writing the HTML directly we decided to use Pug (which compiles into HTML) to build robust HTML sites.

Surface 1 Pro — A development machine

Tue, 22 Oct 2013 00:00:00 +0000

Because many people are asking me how developing software on the Surface 1 Pro works, I’ve decided to write this second recap here. Right now my Surface is about 8 months old, and the general availability of Surface 2 and Surface 2 Pro are an excellent reason to recap.

First of all, I’ll give you a rough overview of what’s installed on my Surface Pro right now — Microsoft Windows 8.1 Enterprise

Top 14 SPC14 Sessions announced

Fri, 18 Oct 2013 00:00:00 +0000

As most SharePoint addicted people already may know, SharePoint Conference 2014 takes place in Las Vegas again starting on 3rd March 2014.

So far nothing new, but the conference team has just published the Top 14 sessions. Most interesting for me will be the ‘Developing on-premises solutions with an eye on the future’ from the development track.

At Experts Inside we’re currently doing most of our projects within Office 365, but there are still some customers who don’t want to join the cloud. So this session looks promising to me because I’m often faced with questions like ‘What will happen if we go for full-trust solutions’.

Visual Studio 2013 for SharePoint Development — My experience from the Preview Phase

Fri, 18 Oct 2013 00:00:00 +0000

On 18th of October Visual Studio 2013 was published on MSDN. So today (one day later) it’s a perfect day to share my experiences I’ve earned during the preview phase.I’ve installed the VS2013 Preview early in July (it was available since 26th of June) on my SharePoint development system. The first thing I’ve noticed was that I didn’t have to upgrade the solution file, which turned out to be a great benefit because my colleagues could continue working with VS2012 and we didn’t run into merge conflicts because of solution or project file modifications. In August I started a big SharePoint App Project, and I decided to build it by using the Preview. After some initial considerations, we decided to realize the project as a Provider-Hosted-App with SQL Azure Backend. So there were many different aspects of our project.

Yeoman the web development workflow

Fri, 18 Oct 2013 00:00:00 +0000

See other posts on ‘Branding SharePoint sites with yeoman’.

Okay , let’s get started with Yeoman. As I mentioned within the introduction, Yeoman is more a web development workflow for front-end apps than a single tool. Yeoman has been founded by leading JavaScript developers from the community (Paul Irish for example) and is maintained by Google and the community. The most important fact about Yeoman is that Yeoman is based on Node.js, which makes Yeoman available on all popular platforms such as Windows, Linux and of course macOS.

From Zero to Hero — How we brand SharePoint using Yeoman

Tue, 08 Oct 2013 00:00:00 +0000

Branding SharePoint has been taken to a new level with SharePoint 2013; you can now easily brand your SharePoint (on Premises and Demand) by using HTML MasterPages and HTML PageLayouts. This step allows many design agencies to brand SharePoint sites without digging deep into SharePoint Insights. About a year ago Experts Inside was faced with the first huge (really huge) SharePoint 2013 project were we had to provide both custom MasterPages and custom PageLayouts. Starting with HTML was fine, but after a few days working on these artifacts, we recognized that the development workflow isn’t as smart as it could be. Kevin Mees (one of our developers) started with combining both, latest SharePoint capabilities and latest web development tools. After some iterations, we’ve built an incredible development workflow for branding SharePoint portals using the latest languages such as

Talking to SharePoint's REST Services with C# using RESTSharp

Wed, 02 Oct 2013 00:00:00 +0000

When it comes to SharePoint App Development (especially Cloud- and Provider Hosted Apps), most samples out there are demonstrating how to use CSOM from ASP.NET or ASP.NET MVC. Most REST Samples are dedicated to client-side logic either in JavaScript, CoffeeScript or TypeScript.

That’s fine for most scenarios, but for me, it’s important to do as many calls as possible with a single kind of data-access or service consummation.

Therefore I tried to get rid of CSOM calls from my ASP.NET MVC backend (Controllers, Repositories,…) Of course, it’s possible to deal with SharePoint’s REST API by using plain .NET Framework, but it’s not the kind of code I’d like to write in these days.

Repair OneNote sync on iOS7

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

I usually write only stuff related to software development. However, I’ve to share this quick little notes because it can drive you nuts to get OneDrive on the recent iOS release syncing again.

OneNote itself is one of my favorite apps, and I use it every day for personal and professional (shared) note taking. Microsoft did a great job bringing OneNote with an excellent feature-set to all platforms.

As almost every iOS user, I was also looking forward to iOS7 which ships a ton of good stuff I was waiting for. So I decided to update my iPad first. After downloading and installing the update, everything looked, and I was thrilled having the latest and greatest software finally on my device.

Wrong MSDN documentation on SharePoint's REST interface

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

Today I stumbled upon a documentation bug in MSDN (once again). When trying to access the list of all available WebTemplates on a SPWeb, this article describes that you can use SharePoint’s REST interface by sending an HTTP POST request to http://yourtenant.sharepoint.com/sites/yoursite/_api/web/getAvailableWebTemplates(1033).

I was wondering why I should call a GET method using a HTTP POST operation. So I gave it a try. Using Chrome’s Postman plugin (which is fantastic for experimenting with REST interfaces), I tried to call the method as described within the MSDN reference.

ShareCamp 2013 in Vienna

Mon, 09 Sep 2013 00:00:00 +0000

On September the 7th the first ShareCamp in Vienna was celebrated by Austrian SharePoint Community. About 60 SharePoint addicted people came to Vienna, to spend a Saturday in Microsoft Austria’s HQ.

Traditionally the ShareCamp was opened with the session building. Within 30 minutes the attendees formed the entire conference schedule with round about 25 sessions.

The sessions were covering different topics from SharePoint Migration to App Development and from Windows 8 in Enterprises to SkyDrive. Audience discussions popping up during the talks was exciting. Both Speakers and Attendees discussed various topics directly in the session. This is one essential aspect of BarCamps.

Developer Week 2013 — Quick recap

Wed, 26 Jun 2013 00:00:00 +0000

I’m just on my way back from ‘Developer Week 2013’, which is — with more than 1000 attendees — one of the biggest german developer conferences.

I did two talks on SharePoint development. Inspecting the entire session catalog, I noticed that these are the only talks focusing SharePoint which was a little bit frustrating but also challenging on the other side.

You can grab the slides from my first talk ‘New SharePoint APIs’ here.

DotNetDay Franken — Review and Slides

Mon, 24 Jun 2013 00:00:00 +0000

About a week ago I did a presentation on SharePoint’s new App Model to give developers a rough introduction into the new age of SharePoint development.

.NET Day Franken - one of the coolest german community conferences - was celebrated for the 4th time in Nürnberg Germany. It was also the 4th time that I was invited as a speaker, so it’s great to see how the conference is growing and becoming a must-join event for every community member in Germany.

Create a SP2013 VM on Azure using PowerShell

Thu, 23 May 2013 00:00:00 +0000

A few weeks ago Windows Azure IaaS features reached GA. Since then I’m continuously replacing my OnPremise SharePoint development machines by new Azure VMs. To save money, I’m going to remove the virtual machines as soon as I don’t need them. Automating the process of creation and deletion is essential for me because I don’t want to spend a few minutes each day in PowerShell to get my machine up and running.

ShareCamp 2013 Vienna — We're doing it again

Tue, 21 May 2013 00:00:00 +0000

I’m thrilled to announce that we’re organizing another ShareCamp. After participating in the successful fourth edition of our ShareCamp in Munich, we’re now going to add more ShareCamps in different venues.

The upcoming ShareCamp will take place in Microsoft Austria’s headquarter in Vienna on 9th of September. Save the date and visit our ShareCamp Austria site and sign in.

Registration opens now, and we’re currently limited to 75 attendees. So, hurry up and register for the 5th ShareCamp. As every time, attending a ShareCamp is free. We’re also scheduling a ShareCamp Party on Saturday evening. As soon as new information about the party is available, I’ll keep you updated. I want to say thank you to the entire organization-crew, without the great orga-team it would be impossible to schedule such an event.

Productivity boost with SublimeText Plugins

Thu, 18 Apr 2013 00:00:00 +0000

For developing native web languages I use SublimeText 2 (http://www.sublimetext.com/). Like many other editors, SublimeText offers a great plugin ecosystem, which allows you as a developer to add various functionality by installing additional packages.

Within this post I’ll introduce some plugins I’m using to increase my developer performance.

Package Control

Package Control is the most robust and vital plugin; it allows you to add new plugins to sublime without typing endless commands into the console or manually copying files to the application directory. To install Package Control, you’ve to execute the following script from Sublime Text’s Console

Launch modal dialogs from ECB CustomActions from within the HostWeb

Wed, 17 Apr 2013 00:00:00 +0000

When you’re building Apps for SharePoint 2013, you can create Pages, Client Parts or CustomActions.

For CustomActions there are two different targets, either the Ribbon or the Edit Control Block (ECB) in both cases it’s not allowed to inject JavaScript. If SharePoint allowed adding JS in these situations, the client script would run in the context of the HostWeb which would cause possible security leaks.

For ECB CustomActions you can provide an URL-Action which redirects the user to a URL defined by you (the App developer). You can add various tokens to the URL, as a SharePoint developer you’re perhaps aware of this functionality from previous SharePoint versions.

Maintaining Brownfield JS Apps? Check Js2Coffee

Wed, 17 Apr 2013 00:00:00 +0000

Do you love CoffeeScript? Alternatively, you’ve to maintain Brownfield JavaScript based Applications?

Checkout Js2coffee! Js2coffee translates your JavaScript Code into nice, readable and valid CoffeeScript. In addition to the Js2coffee website (js2coffee.org), there is also an NPM package available. You can install it directly from the terminal

npm install js2coffee
# or globally
npm install js2coffee --g

You can translate your JS file easily by providing the following command.

ShareCamp 2013 recap

Tue, 16 Apr 2013 00:00:00 +0000

Last weekend we did our fourth ShareCamp at Microsoft’s German headquarter in Munich (Unterschleißheim). The ShareCamp is not a typical conference; it’s a BarCamp, BarCamps typically have no schedule until the conference starts. Every attendee can submit sessions, discussions or Hands-On Workshops.

Therefore it’s great for people who’d never spoken at huge, favorite conferences. The entire audience votes for the session proposals and depending on these votes sessions are moved to bigger or smaller rooms. (More information on BarCamps can be found here http://en.wikipedia.org/wiki/BarCamp).

Windows Azure Global Bootcamp

Tue, 16 Apr 2013 00:00:00 +0000

Since global availability of SharePoint 2013, Azure is getting more and more critical for SharePoint and SharePoint Online. As a developer, you can create Apps for SharePoint using Azure as the platform for your custom website, which will interact with your SharePoint instance.

Therefore almost every SharePoint dev should be familiar with Windows Azure and it services. Microsoft Azure MVPs and the Microsoft Azure community are organizing a global BootCamp for Azure on 27th of April 2013.

Windows Azure IaaS reaches GA

Tue, 16 Apr 2013 00:00:00 +0000

Windows Azure’s IaaS components have just reached GA (General Availability) status. There is also a SharePoint Template existing which can be used to host SharePoint 2013 Farms on Windows Azure IaaS. Microsoft is also providing a whitepaper describing how to scale and create a SharePoint Farm on Windows Azure using all the great features offered by the Windows Azure Cloud. You can find the whitepaper here (http://go.microsoft.com/fwlink/?LinkID=288782&clcid=0x409)

Prevent errors while using SPWebConfigModification

Thu, 11 Apr 2013 00:00:00 +0000

Today I ran into an issue with SPWebConfigModification.

SPWebConfigModification can be used to make changes to SharePoint’s web.config. The advantage of using SPWebConfigModification - instead of manually changing web.config files on each server - is that changes are applied automatically to each Web Frontend Server (WFE) in the farm.

Internally SharePoint is holding a collection of modifications (a collection of SPWebConfigModification) that should be applied to the web.config File. Once a modification failed, this particular instance of SPWebConfigModification may resist within the collection. Therefore you should always clear the collection directly before staging your modifications on an instance of SPWebApplication.

10 Days using Surface Pro — A developers review

Thu, 28 Feb 2013 00:00:00 +0000

While visiting the Global MVP Summit 2013 in Redmond, I decided to buy a Surface Pro, because they don’t sell it in Germany at this time. There were more reasons why I bought the Surface Pro in opposite to other devices such as Lenovo’s Yoga — which is also really awesome — or perhaps a Samsung Slate or HP’s Envy.

Surface offers pen support which is working like a charm, it’s really smooth; you get fast feedback and it’s really, really precise.
Surface is the fastest tablet with Win8 on it. (Did ultimate developer test -> VS 2012 Startup-Sequence) 😀
No matter when Surface Pro will be shipped in Germany, but there will be accessory, I hope so 😉
Surface is really handy and it isn’t that heavy as news sites are telling you
Surface is also cheaper than comparable competitors
It offers 4 gigs of RAM

Okay these were a few reasons why I bought it, but now let’s move on, I’d like to share my experience with Surface PRO.

Yammer vs SharePoint Social in 2013

Tue, 26 Feb 2013 00:00:00 +0000

There are several discussions on SharePoint’s social strategy going on at the moment. I had some great discussions with my MVP mate Adis Jugo during Summit last week. Since #SPC12 almost every SharePoint addicted developer, it-pro, power user has reviewed Yammer. If you don’t know what Yammer is, here a short introduction.

Yammer is an enterprise social network, which allows you and your coworkers to communicate in a modern way as on Facebook. The vast difference between Facebook and Yammer is, Yammer is private. That means only people from your organization or the people you’ve invited to join your network can see and take part in the conversation which is going on in your Yammer network. With the common understanding of Yammer, you should be able to follow up the ongoing discussions. Adis wrote a great post, summarizing his thoughts on SharePoint and Yammer integration and the upcoming social future. I agree with Adis; many things are missing at the moment. However, here my thoughts on Yammer vs. SPSocial

Contact

Mon, 01 Jan 0001 00:00:00 +0000

I’m more than happy to connect. Just drop me a line.

Legal Disclosure

Mon, 01 Jan 0001 00:00:00 +0000

Information in accordance with Section 5 TMG

Thorsten Hans

Bühlrech 10

66620 Nonnweiler

Contact Information

Telephone: 0151 46680872

E-Mail: thorsten.hans@gmail.com

Internet address: https://thorsten-hans.com

Graphics and Image Sources

https://unsplash.com/

Disclaimer

Accountability for content

The contents of our pages have been created with the utmost care. However, we cannot guarantee the contents’ accuracy, completeness or topicality. According to statutory provisions, we are furthermore responsible for our own content on these web pages. In this matter, please note that we are not obliged to monitor the transmitted or saved information of third parties, or investigate circumstances pointing to illegal activity. Our obligations to remove or block the use of information under generally applicable laws remain unaffected by this as per §§ 8 to 10 of the Telemedia Act (TMG).

Privacy Policy

Mon, 01 Jan 0001 00:00:00 +0000

We are very delighted that you have shown interest in our enterprise. Data protection is of a particularly high priority for the management of the Thorsten Hans. The use of the Internet pages of the Thorsten Hans is possible without any indication of personal data; however, if a data subject wants to use special enterprise services via our website, processing of personal data could become necessary. If the processing of personal data is necessary and there is no statutory basis for such processing, we generally obtain consent from the data subject.

Search

Mon, 01 Jan 0001 00:00:00 +0000

Talks & Publications

Mon, 01 Jan 0001 00:00:00 +0000

I’m actively contributing to different technology communities for more than a decade now. My contributions reach from articles for print and online developer magazines over meetups and user-groups to talks and workshops for the biggest international developer conferences.

Public Speaking

Thorsten Hans on Stage

With more than 300 public talks on software development related topics, it’s tough to keep a list of all sessions and workshops up-to-date. Instead, I’d like to share some of my personal highlights. See this unsorted list of conferences, I contributed to:

Thorsten Hans

Book Progress & Illustrations

Book Progress & Thoughts on Inclusive Pricing

Now

Location

Work

Projects

Life

I’m Writing a Book on WebAssembly and Spin

Building Serverless Applications With WebAssembly & Spin

Sign up and Stay in the Loop

Component Composition with Spin 4.0

What You Need To Follow Along

Azure DevOps Extensions for Spin, Fermyon Wasm Functions and Fermyon Cloud

What I’ve Been Up To

Uses

Hardware

Software

Accessories

Archive

WebAssembly and Containers with Docker Desktop - Hello World & Beyond

What we are going to build

Wasm ahead - Joining Fermyon

A Farewell to Thinktecture

A comprehensive guide on authoring plugins for Fermyon Spin

Weekly Rust Trivia: How to use pattern matching

Weekly Rust Trivia: How to share state between threads

Weekly Rust Trivia: How to write a function-like macro

Weekly Rust Trivia: How to write an HTTP API with Actix

Weekly Rust Trivia: How to Implement the Builder Pattern

Weekly Rust Trivia: How to Implement a Generic Stack

Weekly Rust Trivia: How to Retrieve Image Dimensions

Weekly Rust Trivia: How to create a TCP Server

Weekly Rust Trivia: How to Implement Binary Search

Weekly Rust Trivia: How to Read a CSV File

How to use Azure Cosmos DB as a key-value store for Fermyon Spin

Provision necessary Azure Infrastructure

Weekly Rust Trivia: How to Compute a SHA256 Hash of a File

Weekly Rust Trivia: How to Download an Image to a File

Weekly Rust Trivia: How to Get all Files in a Directory

How I replaced the backend of my blog with Spin & Fermyon Cloud

A First Glance at the Spin Router for Rust

What’s the purpose of a router in HTTP apps?

Let's build a HTTP router for Spin with Rust

Let Spin lift your key-value store

What are key-value stores

CRUD in WebAssembly with Fermyon Spin and MySQL

Master configuration data in Fermyon Spin

Azure Blob Storage using the Azure SDK for Go

Building Microservices With WebAssembly and Fermyon Spin

Hot-Reload .NET Configuration in Kubernetes with ConfigMaps

Instrumenting .NET Apps with OpenTelemetry

What is OpenTelemetry

Background Workers in Azure Container Apps with KEDA

How to build multi-arch Docker Images with ease

Provision AKS and NAT Gateway with Terraform

Patch Kubernetes objects with .NET: The Simple Way

How to Deploy Azure Container Apps with Terraform

Let's build a gRPC server and client in Rust with tonic

Awarded as a Docker Captain and as a Microsoft MVP

Docker Captain 2022

Docker SBOM - or how to dive into shift-left security

az containerapp up - AKA amazing inner-loop performance

What does az containerapp up actually do?

How to lint Docker images with Dockle

Why should we lint container images

Check if your application is running in a Docker container

Managed Identities With Azure Container Apps

Speaker Bio

English Speaker Bio

German Speaker Bio

Logging in Kubernetes with Loki and the PLG stack

Let's build a CLI in Go with Cobra

https://github.com/spf13/cobra

Custom health probes with Azure Container Apps

How to run your own Helm Repository on Azure Container Apps

Master Azure CLI queries - The missing manual

Custom health probes with Application Gateway Ingress Controller

Exposing gRPC services in Azure Container Apps

Automate Azure with Azure Functions and Go

What does `az containerapp up` actually do?