PAUL'S BLOG

Installing VMware Workstation Pro 25H2 on Ubuntu Desktop

Mon, 20 Apr 2026 13:00:00 +0000

Last year, I wrote a guide on how to install VMware Workstation Pro on Ubuntu Desktop. Since then, I’ve learned there’s an easier way to manually install and sign the vmmon and vmnet modules when attempting to run VMware Workstation Pro on a UEFI-based system with secure boot enabled. No more custom building of the modules required! The modules can be installed using VMware’s installer, and you just need to manually sign them. Let’s go through this process step by step.

Study Guide: Kubernetes and Cloud Native Associate (KCNA)

Fri, 19 Dec 2025 13:00:00 +0000

My KCNA certification is up for renewal, and as I’m preparing to retake the exam, it dawned on me that I wrote up a study guide for it never actually published it. Doh! 🫣

So here it is 🤗

The KCNA is a great entry point for anyone looking to validate their foundational knowledge of Kubernetes and the cloud native ecosystem. I thought it would be helpful to document my study notes and share them with others who are also preparing for the exam.

Local LLMs: Running Ollama and Open WebUI in Docker on Ubuntu

Wed, 08 Oct 2025 13:00:00 +0000

Ollama is a popular tool for running large language models (LLMs) locally on your machine. It provides a simple interface to interact with various models without needing an internet connection. Open WebUI is a web-based user interface that allows you to interact with LLMs through a browser.

I am working on an Ubuntu 24.04.3 LTS Desktop machine with decent hardware to run models locally, so my preference is to run Ollama as a local service rather than confining it to a container. This way, Ollama can take full advantage of my machine’s capabilities, especially the GPU.

Build a Weather MCP Server with Rust: Complete Tutorial for AI Integration

Tue, 10 Jun 2025 13:00:00 +0000

Building AI tools that can access real-time data requires bridging the gap between language models and external APIs. The Model Context Protocol (MCP) makes this possible by providing a standard way for AI assistants to interact with data sources.

In this tutorial, we’ll build a weather MCP server using Rust that connects to the National Weather Service API, giving any MCP-compatible AI assistant the ability to fetch live weather alerts and forecasts.

Deploying AKS Automatic clusters with Pulumi: A step-by-step guide

Mon, 10 Mar 2025 13:00:00 +0000

Yo! Let’s build an AKS Automatic cluster with Pulumi 🚀

If you don’t already know, Pulumi is a modern Infrastructure as Code (IaC) tool that allows you to use your favorite programming language to deploy and manage cloud resources. I like it because I can use Go and the Pulumi Go SDK to write my infrastructure code. There are other languages supported like Python, TypeScript, .NET, and more so be sure to check out their docs for more information.

Installing VMware Workstation Pro on Ubuntu Desktop

Mon, 03 Mar 2025 13:00:00 +0000

This is a guide that will walk you through the steps to install VMware Workstation Pro on Ubuntu Desktop. I am currently using Ubuntu 24.10 with version 6.11.x of the Linux kernel on a UEFI-based system with secure boot enabled. This guide is based on my experience with this setup and may not apply to all systems.

Download VMware Workstation Pro

To start, browse to https://support.broadcom.com and login or create an account if you don’t already have one.

Certified Argo Project Associate (CAPA) Exam Study Guide

Thu, 06 Feb 2025 13:00:00 +0000

I recently passed the Certified Argo Project Associate (CAPA) exam and wanted to share a study guide to help you prepare for the exam. If you are not already aware, the Cloud Native Computing Foundation (CNCF) offers a suite of certifications that validate your knowledge and expertise in cloud-native technologies, with Argo being one of them.

The CAPA exam is designed for beginners who are new to Argo and its suite of tools which includes Argo Workflows, Argo CD, Argo Rollouts, and Argo Events.

Installing Kubernetes 1.30

Fri, 09 Aug 2024 13:00:00 +0000

Kubernetes on your Laptop (3 part series)

This is the third and final post in my “Kubernetes on your Laptop” series. In this post, I will show you how to install Kubernetes on Ubuntu server. If you haven’t read the previous posts, I recommend you go back and ensure you have an Ubuntu server running on your laptop before proceeding.

Installing Ubuntu Server 22.04

Thu, 08 Aug 2024 13:00:00 +0000

Kubernetes on your Laptop (3 part series)

This is the second post in my “Kubernetes on your Laptop” series. In this post, I’ll show you how to install Ubuntu Server on a virtual machine using VMware Fusion. If you need help installing VMware Fusion, check out my previous post.

Download Ubuntu Server Image

First thing we need to do is download the Ubuntu Server image based on your machine’s architecture:

Installing VMware Fusion

Wed, 07 Aug 2024 13:00:00 +0000

Kubernetes on your Laptop (3 part series)

I’m preparing to renew my CKA and CKS certifications, and to practice, I’ve decided to set up a local Kubernetes cluster as a lab environment on my laptop to work with control plane components which isn’t be possible in a managed Kubernetes environment like GKE, EKS, or AKS. There are other local Kubernetes options like Minikube, Kind, Docker Desktop, or Rancher Desktop but you may run into some limitations especially as you try to prepare for the CKA and CKS exams. I wanted to have a full-blown Kubernetes cluster running locally without any restrictions.

Study Guide: Kubernetes Certified Security Associate (KCSA)

Tue, 23 Jul 2024 13:00:00 +0000

I’ve been studying for the Kubernetes Certified Security Associate (KCSA) exam, and I thought it would be helpful to document my study notes and share them with others who are also preparing for the exam.

This article is a bit long but it will cover everything you need to know to pass the KCSA exam. I’ll be updating this article as I find additional content to share, so make sure to bookmark it and check back often.

Publishing Helm Charts to GitHub Container Registry

Mon, 22 Jul 2024 13:00:00 +0000

So you have a local Helm chart that you want to share with others?

In this quick tutorial, I’ll walk you through the process of publishing Helm charts to your very own Helm repository using GitHub Container Registry and GitHub Pages using GitHub Actions.

Before you begin, make sure you have the following prerequisites:

A GitHub account
A GitHub repository with your Helm chart
GitHub CLI installed on your local machine
Bash shell

GitHub Pages Setup

We will use GitHub Pages to host the Helm repository. So you will need to create a new branch called gh-pages. This branch will contain the Helm chart binaries and a README.md file with instructions on how to use the helm repo and install its charts.

Publishing Container Images to GitHub Container Registry

Tue, 18 Jun 2024 13:00:00 +0000

Do you have a container image that you want to share with the world? GitHub Container Registry (GHCR) is a great place to store and share your container images. In this tutorial, we’ll show you how to publish container images to GHCR using GitHub Actions.

Start by creating a new repository on GitHub or cloning an existing one. Then make sure you have a Dockerfile in the root of your repository.

You Down with PDB?

Fri, 22 Mar 2024 13:00:00 +0000

P.D.B. how can I explain it
I’ll take you frame by frame it
To have y’all all jumpin’, shoutin’, sayin’ it
P is for Pod, D is for Disruption, reboot and watch it ripple
The last B, well, that’s super simple

~ An ode to Naughty by Nature’s track titled O.P.P. which Microsoft Copilot helped me write 😂

Overview

In this post, we’ll take a look at Kubernetes Pod Disruption Budgets (PDBs) and how they can be used to ensure that your applications remain available during planned disruptions.

Adding a GitHub Codespace button to your README

Thu, 21 Mar 2024 13:00:00 +0000

GitHub Codespaces is a great way to make it easier for people to contribute to your project. With a few clicks, folks can spin up a Codespace environment with all necessary tooling installed and be productive right away. But it does take a few clicks and this quick post is to show how you can save developers a click or two because every click matters 😆

With one line of markdown in your README, you can add a button that looks like this…

Soaring to New Heights with Kaito: The Kubernetes AI Toolchain Operator

Wed, 20 Mar 2024 14:00:00 +0000

Earlier today at KubeCon Europe 2024, Jorge Palma of the AKS team gave a keynote talk on Kaito, the Kubernetes AI Toolchain Operator.

Next keynote speaker @jorgefpalma 🙌 we are truly living in the AI revolution pic.twitter.com/ATxLWUKDeD
— CNCF (@CloudNativeFdn) March 20, 2024

This tool has been released as an open-source project a few months back and you may or may not have heard of it.

So if you don’t know, now you know…

You’re probably thinking, “but what is it, and what can it do for me?” 🤔

Strengthening the Secure Supply Chain

Sun, 17 Mar 2024 13:00:00 +0000

This post will walk you through a demo I presented at the SCaLE21X conference. The session is titled, Strengthening the Secure Supply Chain with Project Copacetic, Eraser, and FluxCD and this step-by-step guide will enable you do it on your own.

Prerequisites

To begin, you will need to have the following:

Docker Desktop to run a Kubernetes cluster locally
Git to clone the demo repository
GitHub account

We will also be using the following tools:

KubeConNA | Building Carbon Awareness with KEDA: Taking the First Step Towards Sustainability

Thu, 16 Nov 2023 13:00:00 +0000

Speaking at KubeConNA 2023 was an awesome experience. But what was equally awesome was being able to speak about a topic and project that was very close to my heart. I spoke about how we can build carbon awareness on the Kubernetes platform with the open-source KEDA project, and how we can take the first step towards sustainability just by being aware of the carbon intensity of energy produced during time periods and reducing our demand for energy during those periods.

Bootstrap your GitOps-enabled AKS cluster with Terraform: A code sample using the Flux v2 K8s Extension

Thu, 28 Sep 2023 13:00:00 +0000

In my previous posts, we learned how to get started with GitOps on AKS using the K8s extension for AKS.

Then, we took a look at the Flux CLI and explored how it can be used to bootstrap your cluster and generate FluxCD manifests so that we can use GitOps to implement GitOps 🤯, and implemented Flux’s image update automation capability.

From there, we built on the concept of image update automation, and showed you how you can use Flagger to automate canary deployments.

Progressive Delivery on AKS: A Step-by-Step Guide using Flagger with Istio and FluxCD

Tue, 26 Sep 2023 13:00:00 +0000

In my previous post, we setup an Azure Kubernetes Service (AKS) cluster to automatically update images based on new image tags in a container registry. As soon as a new image was pushed to the registry the image was immediately updated.

But what if you don’t want an agent automatically pushing out new images without some sort of testing? 🤔

In this article, we’ll build upon Flux’s image update automation capability and add Flagger to implement a canary release strategy.

Automating Image Updates with FluxCD on AKS

Fri, 22 Sep 2023 13:00:00 +0000

In my previous post, we walked through the setup of FluxCD on AKS via AKS extensions. In this article, we’ll go a bit deeper and take a look at how you can use FluxCD to automate image updates in your AKS cluster.

The goal here is to streamline the process of updating your application deployments in your cluster.

Here is our intended workflow:

Modify application code, then commit and push the change to the repo.
Create a new release in GitHub which kicks off a release workflow to build and push an updated container image to a GitHub Container Registry.
FluxCD detects the new image and updates the image tag in the cluster.
FluxCD rolls out the new image to the cluster.

We’ll use same AKS store demo app we used in the previous post, but this time we’ll go a bit faster.

Git going with GitOps on AKS: A Step-by-Step Guide using FluxCD AKS Extension

Wed, 20 Sep 2023 13:00:00 +0000

In reading through @StevenMurawski’s blog post titled, What Really is GitOps? we learned that GitOps is a way to do Continuous Delivery of our applications on Kubernetes.

In this post, I will jump right into how you can “git” going with GitOps by enabling the FluxCD AKS Extension on your Azure Kubernetes Service (AKS) and using a tool called Kustomize to help with Kubernetes configuration management.

We’ll deploy my new favorite demo app, AKS Store Demo to our AKS cluster and then make some changes to the application and see how FluxCD handles them.

Installing .NET on Ubuntu

Sat, 09 Sep 2023 13:00:00 +0000

Installing .NET on Ubuntu is supposed to be easy. Sometimes it’s not. You should be able to follow the instructions on the Microsoft docs and install from a package manager but I’ve had issues with that. It’s been a frustrating experience; the package installs but then I can’t run dotnet --version and I can’t figure out why.

Thankfully there is an option to manually install .NET, this is what I’ve had the most success with.

Pushing Multi-Architecture Container Images

Thu, 07 Sep 2023 13:00:00 +0000

Introduction

My previous article, Building Multi-Architecture Container Images, covered the basics of building multi-architecture container images using Docker Buildx. In this article, we’ll explore how to push multi-architecture container images to Azure Container Registry (ACR) using GitHub Actions.

What is a GitHub Action?

GitHub Actions is a continuous integration and continuous deployment (CI/CD) platform built into GitHub. It allows you to automate, customize, and execute your software development workflows. Using GitHub Actions, you can create workflows that respond to GitHub events, such as push, issue creation, or a new release.

Building Multi-Architecture Container Images

Tue, 05 Sep 2023 13:00:00 +0000

Introduction

Over the past several years, we’ve seen the emergence of the ARM64 architecture, which is gaining popularity due to its energy efficiency and performance benefits. We often seen these processors in mobile devices, such as smartphones and tablets. We also seen them in our IoT devices, such as smartwatches and smart TVs. Now, we are starting to see increased adoption of ARM64 processors in servers and personal computers.

This emergence of the ARM64 architecture, means that we now have two major processor architectures to consider when building and deploying our containerized applications in order to maximize our application’s reach.

Does Workload Identity on AKS work across tenants?

Fri, 25 Aug 2023 13:00:00 +0000

Introduction

An interesting use case for Workload Identity came up recently. I was asked if a Pod in an AKS cluster that was deployed in one tenant can access Azure resources within another tenant.

I’ve configured Workload Identity on AKS many times, and I thought “in theory” it should “just work”, but I never tested it across tenants. So I decided to give it a try.

TL;DR: Yes, it does work.

Streamline Network Observability on AKS: A Step-by-Step Guide to enable the AKS add-on with Terraform

Mon, 10 Jul 2023 13:00:00 +0000

Have you ever had to troubleshoot network issues in your Kubernetes clusters? If so, you know how challenging it can be to identify and resolve problems.

To troubleshoot network issues you probably had to use a combination of tools like kubectl, tcpdump, wireshark, and netstat. The list goes on and on… While these tools are great for debugging and capturing network logs and traces, they don’t provide a holistic view of your cluster’s network traffic.

Efficient Configuration Management in AKS: Integrating Azure App Configuration for Seamless Loading of Key-Value Pairs into Config Maps

Tue, 13 Jun 2023 06:00:00 -0700

Did you know that Azure App Configuration Service is a managed service that helps you centralize your application configuration? It provides a way to store all your app configs in one place and manage them centrally. It also provides a way to manage feature flags and control feature rollouts. I highlighted the feature management capabilities in a breakout session the Microsoft Build conference a few weeks ago. If you have not watched the session yet, you can find the recording here

#MSBuild | Integrating Azure AI and Azure Kubernetes Service to build intelligent apps | BRK225H

Fri, 02 Jun 2023 14:05:46 -0800

I had the opportunity to speak at #MSBuild 2023. Build is Microsoft’s largest developer conference held every year in May. This year, we were lucky enough to get back to a full in-person experience with plenty of awesome sessions with tons of technical demos. I shared the stage with Jorge Palma from the AKS PM team, and we spoke about how you can to integrate Azure AI and Azure Kubernetes Service to build and run your intelligent apps.

Purging Deleted Azure Key Vaults

Mon, 27 Feb 2023 13:09:20 -0800

Do you constantly provision and delete Azure Key Vaults?

If so, you may have noticed attempts to recreate a recently deleted key vault will result in the following error:

The vault name is already in use.

This is because Azure Key Vaults are kept in a deleted state and not automatically purged. You must manually purge these key vaults to be able to reuse the name.

To confirm the key vault in question is in “deleted” state, you can run the following:

Effortlessly Deploy to Azure Kubernetes with Open Source Tools Draft and Acorn

Tue, 03 Jan 2023 11:11:01 -0800

UPDATE On March 15, 2024 Acorn Labs announced that they will be shifting focus to developing an LLM app platform based on GPT-Script technology and has archived the Acorn Runtime project.

In this post, I’ll walk you through deploying a web application to Azure Kubernetes Service (AKS) without having to write any Docker or Kubernetes manifest files.

Using open-source command-line tools Draft and Acorn, we’ll containerize and deploy to AKS in just a few steps! Let’s go 🚀

Service Mesh Considerations

Wed, 14 Dec 2022 07:00:00 -0700

“Build microservices”, they said… “it’ll be fun”, they said…

There are many reasons why you would want to deploy a solution based on the microservices architectural pattern, but it comes at a cost. More microservices means more deployments to manage, more microservices to connect, more microservices to secure… yeah, it gets complex real quick.

If you’re just getting started with microservices or have a small number of microservices deployed, you may have heard of the term “service mesh”, but not needed one yet.

Re-visiting Dev Container Features

Fri, 02 Dec 2022 08:00:10 -0700

A few months ago I wrote a post that described how you can add custom features to your Dev Containers. That didn’t age very well 😅

But good news is that there is a better way to add or extend functionality for your Dev Containers. 🥳

Since my original post, @BrigitMurtaugh published a post on the VS Code blog announcing new repos, the open dev container specification and discussed a new way of adding features. If you haven’t read the post, go check it out here.

Web Application Routing on AKS

Wed, 16 Nov 2022 07:00:00 -0700

Exposing your web applications on Azure Kubernetes Service (AKS) has gotten a little bit easier. In this post, I will cover the new Web Application Routing feature for AKS and discuss reasons why you may want to implement it within your cluster.

Exposing your app

You have a lot of options when it comes to exposing your application Pods to the world. If you’re using a managed-Kubernetes service in the cloud, you could deploy a Service and set the type to LoadBalancer and your cloud provider will provision one with a public IP. The Service sits in front of your Pods and if all you need is a public IP, you’re good to go.

Ubuntu Dev Tools

Fri, 11 Nov 2022 06:57:20 -0800

Is this the year of the Linux desktop? I’m not sure but I have been making more of an effort to “daily drive” a Linux desktop lately. I’m currently working off of an Ubuntu 22.10 machine and here is my script for installing common tools that I work with daily.

sudo apt-get update
sudo apt-get upgrade

# add git repository
sudo add-apt-repository ppa:git-core/ppa

# install some basic tools
sudo apt-get update
sudo apt-get install -y \
 python3 \
 python3-pip \
 bpytop \
 tree \
 guvcview \
 vim \
 curl \
 git \
 gnupg2 \
 jq \
 sudo \
 zsh \
 build-essential \
 cmake \
 libssl-dev \
 openssl \
 unzip \
 pkg-config

# install brew tools
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo '# Set PATH, MANPATH, etc., for Homebrew.' >> /home/paul/.zshrc
echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> /home/paul/.zshrc
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
brew install gcc

# install hugo 
brew install hugo

# install azure cli
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# install dotnet6
sudo apt-get install dotnet6

# install go
wget https://go.dev/dl/go1.19.3.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.19.3.linux-amd64.tar.gz
echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.zshrc
rm go1.19.3.linux-amd64.tar.gz

# install kubectl
sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

# install docker desktop
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
 "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
wget https://desktop.docker.com/linux/main/amd64/docker-desktop-4.13.1-amd64.deb
sudo apt-get update
sudo apt-get install -y ./docker-desktop-4.13.1-amd64.deb
rm docker-desktop-4.13.1-amd64.deb

# install rancher desktop
curl -s https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/Release.key | gpg --dearmor | sudo dd status=none of=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg
echo 'deb [signed-by=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg] https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/ ./' | sudo dd status=none of=/etc/apt/sources.list.d/isv-rancher-stable.list
sudo apt-get update
sudo apt-get install -y rancher-desktop

# install hashi tools
wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com jammy main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update
sudo apt-get install -y terraform packer consul nomad vault waypoint

# install node
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion" # This loads nvm bash_completion
command -v nvm
nvm install 18

# install pulumi
curl -fsSL https://get.pulumi.com | sh

# install rust and toolchains
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
echo "source $HOME/.cargo/env" >> ~/.zshrc
source "$HOME/.cargo/env"
echo "PATH=$PATH:$HOME/.cargo/bin" >> ~/.zshrc
source ~/.zshrc

# install tools for building wasm apps
rustup install nightly
rustup component add rustfmt
rustup component add rustfmt --toolchain nightly
rustup component add clippy
rustup component add clippy --toolchain nightly
cargo install cargo-expand
cargo install cargo-edit
cargo install cargo-generate
cargo install --git https://github.com/bytecodealliance/wit-bindgen wit-bindgen-cli --tag v0.2.0
rustup target add wasm32-wasi
rustup target add wasm32-unknown-unknown

# install rustwasm
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

# install wasmtime
curl https://wasmtime.dev/install.sh -sSf | bash

# install snaps
sudo snap install --classic code
sudo snap install spotify
sudo snap install postman
sudo snap install zoom-client
sudo snap install sublime-text --classic
sudo snap install storage-explorer
sudo snap install obs-studio
sudo snap install discord
sudo snap install slack --classic
sudo snap install vlc

Rust for the Impatient

Thu, 10 Nov 2022 19:34:46 -0800

An awesome video to quickly get up to speed on how to read Rust code. Be sure to give the video a 👍

Fixing a NodeJS Digital Envelope Routines Error

Tue, 08 Nov 2022 19:55:21 -0800

In my journey to learn Rust, I’ve decided to pick up this book called “Practical Rust Web Projects” by Shing Lyu.

In the last chapter, you walk through an example of packaging a WebAssembly module using wasm-pack and using the .wasm binary in a NodeJS application. On the step where I needed to compile the application, I ran into the following error:

$ npm run build

> create-wasm-app@0.1.0 build
> webpack --config webpack.config.js

node:internal/crypto/hash:71
 this[kHandle] = new _Hash(algorithm, xofLen);
 ^

Error: error:0308010C:digital envelope routines::unsupported
 at new Hash (node:internal/crypto/hash:71:19)
 at Object.createHash (node:crypto:133:10)
 at module.exports (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/webpack/lib/util/createHash.js:135:53)
 at NormalModule._initBuildHash (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/webpack/lib/NormalModule.js:417:16)
 at handleParseError (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/webpack/lib/NormalModule.js:471:10)
 at /Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/webpack/lib/NormalModule.js:503:5
 at /Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/webpack/lib/NormalModule.js:358:12
 at /Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/loader-runner/lib/LoaderRunner.js:373:3
 at iterateNormalLoaders (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/loader-runner/lib/LoaderRunner.js:214:10)
 at Array.<anonymous> (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/loader-runner/lib/LoaderRunner.js:205:4)
 at Storage.finished (/Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js:43:16)
 at /Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js:79:9
 at /Users/paul/repos/Apress/practical-rust-web-projects/Ch06/hello-wasm/client/node_modules/graceful-fs/graceful-fs.js:78:16
 at FSReqCallback.readFileAfterClose [as oncomplete] (node:internal/fs/read_file_context:68:3) {
 opensslErrorStack: [ 'error:03000086:digital envelope routines::initialization error' ],
 library: 'digital envelope routines',
 reason: 'unsupported',
 code: 'ERR_OSSL_EVP_UNSUPPORTED'
}

Node.js v18.7.0

After a bit of Googling, I ran across someone suggesting to run the following command:

Deploying ARM64 workloads to AKS

Wed, 02 Nov 2022 07:00:00 -0700

You might have heard by now that Azure has partnered with Ampere to bring ARM-based processors for virtual machines on Azure. This is super exciting as it gives you an opportunity to deploy workloads on highly performant and power efficient virtual machines and these characteristics ultimately result in excellent price-performance (lower costs 🥳)

So… are you ready to deploy your workloads to ARM64 node pools on AKS? I sure wasn’t when attempting to deploy the azure-voting-app-redis application to my cluster.

Sharing Bicep Modules with Azure Container Registry

Tue, 11 Oct 2022 07:00:00 -0700

One of the things I do as a Cloud Native Advocate at Microsoft is build end-to-end lab scenarios in the https://aka.ms/oss-labs repo. Most of the demo scenarios we aim to cover is in and around the container space and a majority of the labs uses Azure Bicep to declaratively provision Azure infrastructure. As more labs get spun up, there is a potential for redundant Bicep code. You might have already guessed, there’s a need for re-usable code to spin up AKS clusters.

Autoscaling Azure Container Apps

Sun, 11 Sep 2022 06:00:00 -0700

So, what makes Azure Container Apps “serverless”?

Today we are going to focus on what makes Azure Container Apps (ACA) a “serverless” offering. But what does the term “serverless” really mean? As much as we’d like to think there aren’t any servers involved, that is certainly not the case. In general, “serverless” means that most (if not all) server maintenance has been abstracted away from you.

With serverless, you don’t spend any time managing and patching servers. This concern is offloaded to Azure and you simply focus on adding business value through application delivery. In addition to operational efficiency, cost efficiency can be achieved with serverless on-demand pricing models. Your workload horizontally scales out based on need and you only pay for what you use. To me, this is serverless, and my teammate @StevenMurawski said it best… “being able to scale to zero is what gives ACA it’s serverless magic.”

Microservices Communications with Azure Container Apps

Sat, 10 Sep 2022 06:00:00 -0700

Introduction

In yesterday’s #ServerlessSeptember post, we learned what the Azure Container Apps (ACA) service is and the problems it aims to solve. It is considered to be a Container-as-a-Service platform since much of the complex implementation details of running a Kubernetes cluster is managed for you.

Some of the use cases for ACA include event-driven processing jobs and background tasks, but this article will focus on hosting microservices, and how they can communicate with each other within the ACA service. At the end of this article, you will have a solid understanding of how networking and communication is handled and will leave you with a few tutorials to try.

Monitoring Azure Container Apps With Azure Managed Grafana

Fri, 09 Sep 2022 06:00:00 -0700

The Azure Monitor team has announced the general availability of the Azure Managed Grafana (AMG) service. As part of the announcement, they also announced the availability of curated Grafana dashboards for various Azure services including Azure Container Apps 🎉

Grafana is very popular within the Cloud Native community and it seems natural to use it for Azure Container Apps (ACA) observability.

In this post, I will walk you through provisioning the ACA and AMG resources using the Terraform AzAPI provider and show you how easy it is to import the ACA dashboards into your AMG instance.

Terraform: Azure Container Apps with Azure Managed Grafana using the AzAPI provider

Fri, 09 Sep 2022 06:00:00 -0700

Code snippet for the Monitoring Azure Container Apps With Azure Managed Grafana article.

`main.tf`

terraform {
 required_providers {
 azurerm = {
 source = "hashicorp/azurerm"
 version = ">=3.0.0"
 }

 azapi = {
 source = "azure/azapi"
 version = ">=0.5.0"
 }
 }
}

provider "azurerm" {
 features {
 resource_group {
 prevent_deletion_if_contains_resources = false
 }

 key_vault {
 purge_soft_delete_on_destroy = false
 }
 }
}

resource "random_pet" "aca" {
 length = 2
 separator = ""
}

resource "random_integer" "aca" {
 min = 000
 max = 999
}

resource "random_string" "aca" {
 length = 5
 lower = true
 upper = false
 numeric = true
 special = false

 keepers = {
 # Generate a new random_string on every run to avoid a conflict with the previous revision
 none = timestamp()
 }
}

locals {
 resource_name = format("%s", random_pet.aca.id)
 resource_name_unique = format("%s%s", random_pet.aca.id, random_integer.aca.result)
 location = "eastus"
}

resource "azurerm_resource_group" "aca" {
 name = "rg-${local.resource_name}"
 location = local.location
}

resource "azurerm_log_analytics_workspace" "aca" {
 name = "law-${local.resource_name_unique}"
 resource_group_name = azurerm_resource_group.aca.name
 location = azurerm_resource_group.aca.location
 sku = "PerGB2018"
 retention_in_days = 30
}

# https://docs.microsoft.com//azure/templates/microsoft.app/2022-03-01/managedenvironments?tabs=bicep&pivots=deployment-language-terraform
resource "azapi_resource" "env" {
 type = "Microsoft.App/managedEnvironments@2022-03-01"
 name = "env-${local.resource_name}"
 parent_id = azurerm_resource_group.aca.id
 location = azurerm_resource_group.aca.location

 body = jsonencode({
 properties = {
 appLogsConfiguration = {
 destination = "log-analytics"
 logAnalyticsConfiguration = {
 customerId = azurerm_log_analytics_workspace.aca.workspace_id
 sharedKey = azurerm_log_analytics_workspace.aca.primary_shared_key
 }
 }
 }
 })
}

resource "azapi_resource" "helloworld" {
 type = "Microsoft.App/containerApps@2022-03-01"
 name = "helloworld"
 parent_id = azurerm_resource_group.aca.id
 location = azurerm_resource_group.aca.location

 body = jsonencode({
 properties = {
 managedEnvironmentId = azapi_resource.env.id
 configuration = {
 ingress = {
 allowInsecure = false
 external = true
 targetPort = 80
 traffic = [
 {
 label = "dev"
 latestRevision = true
 weight = 100
 }
 ]
 }
 }
 template = {
 containers = [
 {
 name = "helloworld"
 image = "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest"
 resources = {
 cpu = 0.5
 memory = "1.0Gi"
 }
 }
 ]
 revisionSuffix = random_string.aca.result
 scale = {
 minReplicas = 0
 maxReplicas = 30
 rules = [
 {
 name = "http-rule"
 http = {
 metadata = {
 concurrentRequests = "100"
 }
 }
 }
 ]
 }
 }
 }
 })

 # this tells azapi to pull out properties and stuff into the output attribute for the object
 response_export_values = ["properties.configuration.ingress.fqdn"]
}

data "azurerm_subscription" "aca" {}
data "azurerm_client_config" "aca" {}

resource "azapi_resource" "amg" {
 type = "Microsoft.Dashboard/grafana@2022-08-01"
 name = "amg-${local.resource_name}"
 parent_id = azurerm_resource_group.aca.id
 location = azurerm_resource_group.aca.location

 identity {
 type = "SystemAssigned"
 }

 body = jsonencode({
 properties = {
 apiKey = "Enabled"
 autoGeneratedDomainNameLabelScope = "TenantReuse"
 deterministicOutboundIP = "Enabled"
 publicNetworkAccess = "Enabled"
 zoneRedundancy = "Disabled"
 }
 sku = {
 name = "Standard"
 }
 })

 # this tells azapi to pull out properties and stuff into the output attribute for the object
 response_export_values = ["identity.principalId"]
}

resource "azurerm_role_assignment" "amg_reader" {
 scope = data.azurerm_subscription.aca.id
 role_definition_name = "Monitoring Reader"
 principal_id = jsondecode(azapi_resource.amg.output).identity.principalId
}

resource "azurerm_role_assignment" "amg_admin" {
 scope = azapi_resource.amg.id
 role_definition_name = "Grafana Admin"
 principal_id = data.azurerm_client_config.aca.object_id
}

output "helloworld_ingress_url" {
 value = format("%s%s", "https://", jsondecode(azapi_resource.helloworld.output).properties.configuration.ingress.fqdn)
}

# optional to automate the dashboard import process
resource "null_resource" "aca" {
 provisioner "local-exec" {
 command = <<-EOT
 az config set extension.use_dynamic_install=yes_without_prompt
 az grafana dashboard import -g ${azurerm_resource_group.aca.name} -n ${azapi_resource.amg.name} --definition 16592
 EOT
 }
}

Resource References

Securely connect to your Azure Linux Virtual Machine with Tailscale SSH

Fri, 12 Aug 2022 17:03:14 -0700

Being on the Cloud Advocate team at Microsoft, we’re always looking to empower every developer to achieve more on Azure. One way of doing this is by bringing you hands-on content to deliver end-to-end scenarios using cloud-native and open source technologies.

My colleague on the Cloud Native team, Aaron Wislang has been cooking up a bunch of labs in our Azure Open Source Labs repo and one area we’ve been collaborating on is within the Azure Linux VM space.

Exploring .NET WebAssembly with WASI

Tue, 09 Aug 2022 20:10:43 -0700

Overview

WebAssembly (Wasm) is something that the Cloud Native Advocacy team has been exploring. It has been around for a few years and has mostly been used within browser-based applications. There are many blog posts on what makes WebAssembly an ideal target for running applications (e.g., smaller footprint with .wasm files compared to containers, code isolation, and sandboxing). My colleague Steven Murawski wrote a blog series on getting started with hosting Wasm apps on an emerging PaaS platform called Hippo which is developed by folks at Fermyon. In Part 1 of the series, he introduces topics and define some of the acronyms like “Wagi” and “WASI”. He also introduced a runtime called Wasmtime which implements the WebAssembly System Interface (WASI) standard. This article will walk you through how Steven and I went about getting a .NET console app running as a Wasm app on the Wasmtime runtime in a Dev Container. The .NET console app produced in this article has also been contributed as a csharp template in the yo-wasm repo which is also maintained by Fermyon; so you can quickly test it out for yourself later.

Extending Visual Studio Code Dev Container Features

Wed, 27 Jul 2022 11:32:10 -0700

UPDATE: The dev-container-features-template repo referenced in this post has been archived. Please see my new post here or visit containers.dev for the latest on this topic.

Have you ever wanted to try an Azure CLI extension without having to install the extension yourself on your local machine? VSCode Dev Containers may be a good option.

What is a Dev Container?

Visual Studio Code has an extension called Remote - Containers. This extension lets you use a Docker container as a development environment and is the technology that powers GitHub Codespaces. If you don’t have the option to use Codespaces, the remote container technology also allows you to open build/open the container within your local environment as long as you have Docker Desktop,or Rancher Desktop (with dockerd as the container runtime since containerd will not work with remote containers), or Docker Engine running on your local machine.

Azure AD B2C logouts and redirection URLs

Sat, 18 Jun 2022 13:34:22 -0700

Background

I’ve been helping a client build a customer-facing NodeJS web application which leveraged Azure AD B2C as its identity provider. Things were going well with the development and Azure AD B2C served them really well. It’s cost-effective and gives them all the controls and security features they’ve come to expect with Azure AD (the non-B2C version). As any responsible company, they run penetration tests on the application prior to releasing to production and they identified one item that can pose as a security threat.

Run Terraform With Azure Pipelines

Fri, 25 Feb 2022 17:56:18 -0700

This repo will walk you through an approach to provisioning Azure resources using Terraform code stored in a Git repo and leverage Azure Pipelines (YAML-based) to deploy to dev, test, and prod environments (all in different subscriptions) with approval gates in front of test and prod environments.

Prerequisites

Azure Subscription

If you don’t have Azure, go sign up for a free account and come back.

Azure DevOps

If you do not already have an Azure DevOps organization, follow these instructions to create one.

Run Your Pipelines in Azure Container Instance

Fri, 16 Jul 2021 17:46:10 -0700

Background

Microsoft-hosted Azure Pipeline agent run in the public space; therefore, they can only deploy to environments that are publicly accessible.
Some organizations may need to deploy to target environments that are only accessible within private space (e.g., inside a Azure Virtual Network).
When the target environment is not publicly accessible, deploying self-hosted pipelines agents are a common solution.
Organizations can self-host Azure Pipeline agents on Linux, macOS, or Windows (physical or virtual machines) or Azure Virtual Machine Scale Sets; however, this may introduce unwanted overhead in having to patch and maintain these machines.
The alternative is to run an agent in a Docker container and host it in Azure Container Instance which can run inside of the organization’s virtual network and we’ll explore this option for the rest of this guide.

Architecture

Validating Azure AD B2C Tokens

Mon, 31 May 2021 23:01:10 -0700

I recently ran into an issue where I needed to help a customer validate an Azure AD B2C JWT access token. We tend to take JWT tokens for granted and sometimes forget that they should be validated by the application. I thought this was going to be pretty straight-forward to solve since Azure AD B2C is effectively Azure AD under the hood. I was wrong.

I initially thought browsing to the OIDC metadata endpoint would reveal the info I needed to validate the signature of the JWT but finding the endpoint was my first challenge.

Getting Started With Terraform on Azure

Sat, 24 Apr 2021 17:40:17 -0700

Check out the official Get Started - Azure tutorial here

Terraform basics

Download and Install

Download terraform from https://www.terraform.io/downloads.html
Extract the executable and add the folder to your PATH variable
Open a shell and type terraform version
The basic commands we’ll use are:
- terraform init
- terraform plan
- terraform apply
- terraform destroy
I advise you to use the terraform fmt command often to ensure your scripts well formatted according to HashiCorp’s style conventions

Folder structure

Terrafrom executes on the files within a folder that are named with the .tf extension. Here is what a typical folder structure looks like:

PAUL'S BLOG

Installing VMware Workstation Pro 25H2 on Ubuntu Desktop

Study Guide: Kubernetes and Cloud Native Associate (KCNA)

Local LLMs: Running Ollama and Open WebUI in Docker on Ubuntu

Build a Weather MCP Server with Rust: Complete Tutorial for AI Integration

Deploying AKS Automatic clusters with Pulumi: A step-by-step guide

Installing VMware Workstation Pro on Ubuntu Desktop

Download VMware Workstation Pro

Certified Argo Project Associate (CAPA) Exam Study Guide

Installing Kubernetes 1.30

Kubernetes on your Laptop (3 part series)

Installing Ubuntu Server 22.04

Kubernetes on your Laptop (3 part series)

Download Ubuntu Server Image

Installing VMware Fusion

Kubernetes on your Laptop (3 part series)

Study Guide: Kubernetes Certified Security Associate (KCSA)

Publishing Helm Charts to GitHub Container Registry

GitHub Pages Setup

Publishing Container Images to GitHub Container Registry

You Down with PDB?

Overview

Adding a GitHub Codespace button to your README

Soaring to New Heights with Kaito: The Kubernetes AI Toolchain Operator

Strengthening the Secure Supply Chain

Prerequisites

KubeConNA | Building Carbon Awareness with KEDA: Taking the First Step Towards Sustainability

Bootstrap your GitOps-enabled AKS cluster with Terraform: A code sample using the Flux v2 K8s Extension

Progressive Delivery on AKS: A Step-by-Step Guide using Flagger with Istio and FluxCD

Automating Image Updates with FluxCD on AKS

Git going with GitOps on AKS: A Step-by-Step Guide using FluxCD AKS Extension

Installing .NET on Ubuntu

Pushing Multi-Architecture Container Images

Introduction

What is a GitHub Action?

Building Multi-Architecture Container Images

Introduction

Does Workload Identity on AKS work across tenants?

Introduction

Streamline Network Observability on AKS: A Step-by-Step Guide to enable the AKS add-on with Terraform

Efficient Configuration Management in AKS: Integrating Azure App Configuration for Seamless Loading of Key-Value Pairs into Config Maps

#MSBuild | Integrating Azure AI and Azure Kubernetes Service to build intelligent apps | BRK225H

Purging Deleted Azure Key Vaults

Effortlessly Deploy to Azure Kubernetes with Open Source Tools Draft and Acorn

Service Mesh Considerations

Re-visiting Dev Container Features

Web Application Routing on AKS

Exposing your app

Ubuntu Dev Tools

Rust for the Impatient

Fixing a NodeJS Digital Envelope Routines Error

Deploying ARM64 workloads to AKS

Sharing Bicep Modules with Azure Container Registry

Autoscaling Azure Container Apps

So, what makes Azure Container Apps “serverless”?

Microservices Communications with Azure Container Apps

Introduction

Monitoring Azure Container Apps With Azure Managed Grafana

Terraform: Azure Container Apps with Azure Managed Grafana using the AzAPI provider

main.tf

Resource References

Securely connect to your Azure Linux Virtual Machine with Tailscale SSH

Exploring .NET WebAssembly with WASI

Overview

Extending Visual Studio Code Dev Container Features

What is a Dev Container?

Azure AD B2C logouts and redirection URLs

Background

Run Terraform With Azure Pipelines

Prerequisites

Azure Subscription

Azure DevOps

Run Your Pipelines in Azure Container Instance

Background

Architecture

Validating Azure AD B2C Tokens

Getting Started With Terraform on Azure

Terraform basics

Download and Install

Folder structure

Local LLMs: Running Ollama and Open WebUI in Docker on Ubuntu

`main.tf`