Posts on Virtualthoughts

Gen AI tools are making me lose my fondness for programming

Tue, 18 Nov 2025 00:00:00 +0000

For clarity - I’m not a software engineer but I like writing stuff in Go and have a few side projects. I originally decided to learn Go so I could more effectively read and eventually contribute to open source projects in the K8s space, where there’s a lot of Go.

Almost every day I see posts/articles about how AI’s going to take over software engineering jobs and I find it exhausting because deep down, I know it’s bullshit, but it’s everywhere.

ArgoCD - Ordering with ApplicationSets

Sun, 16 Nov 2025 00:00:00 +0000

In a previous post, I alluded to the use of ApplicationSets for my homelab deployments. I continue to leverage them, to the point I now have quite a number of applications managed by one:

ArgoCD (Itself)
Cert-Manager
Cilium
External-snapshotter
Gateway API CRD’s
Gateway API gateways
Homepage
Kanboard
Kubevirt
Longhorn
OpenTelemetry Operator
Sealed Secrets
System Upgrade Controller

The problem I had, was there was no ordering, dependency management or concurrency limits, so applications would simply update as and whenever changes were pushed.

KubeVirt on ARM64 - CDI Workaround

Mon, 07 Apr 2025 00:00:00 +0000

According to the KubeVirt documentation, CDI is not currently supported on ARM64, which is the architecture my Turing RK1 nodes use.

As a workaround, I experimented with writing an image directly to a PVC which can then be cloned/mounted to a KubeVirt VM. This example dd's an ISO image to a PVC:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: fedora-workstation-pvc
spec:
 accessModes:
 - ReadWriteOnce
 resources:
 requests:
 storage: 30Gi
 volumeMode: Block
---
apiVersion: batch/v1
kind: Job
metadata:
 name: upload-fedora-workstation-job
spec:
 template:
 spec:
 containers:
 - name: writer
 image: fedora:latest
 command: ["/bin/bash", "-c"]
 args:
 - |
 set -e
 echo "[1/3] Installing tools..."
 dnf install -y curl xz
 echo "[2/3] Downloading and decompressing Fedora Workstation image..."
 curl -L https://download.fedoraproject.org/pub/fedora/linux/releases/41/Workstation/aarch64/images/Fedora-Workstation-41-1.4.aarch64.raw.xz | xz -d > /tmp/disk.raw
 echo "[3/3] Writing image to PVC block device..."
 dd if=/tmp/disk.raw of=/dev/vda bs=4M status=progress conv=fsync
 echo "Done writing Fedora Workstation image to PVC!"
 volumeDevices:
 - name: disk
 devicePath: /dev/vda
 volumeMounts:
 - name: tmp
 mountPath: /tmp
 securityContext:
 runAsUser: 0
 restartPolicy: Never
 volumes:
 - name: disk
 persistentVolumeClaim:
 claimName: fedora-workstation-pvc
 - name: tmp
 emptyDir: {}

Which can then be mounted to a VM:

Customising ArgoCD ApplicationSets with Template Patches

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

In a recent attempt to automate my homelab cluster (ref), I now manage all of my cluster applications using ArgoCD, including cilium. I also leverage [applicationSet](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/) objects in ArgoCD as an app-of-apps pattern.

After a Cilium update however, it would fail to sync:

One way to address this is to add `ServerSideApply=true` to the the resulting application manifest:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
 name: bootstrap-applications
 namespace: argocd
spec:
 goTemplate: true
 goTemplateOptions: ["missingkey=error"]
 generators:
 - git:
 repoURL: 'https://github.com/David-VTUK/turing-pi-automation.git'
 revision: HEAD
 directories:
 - path: 'argocd-apps/helm-charts/import-from-cluster-standup/*'
 template:
 metadata:
 name: '{{ .path.basename }}'
 spec:
 project: default
 source:
 repoURL: 'https://github.com/David-VTUK/turing-pi-automation.git'
 targetRevision: HEAD
 path: '{{ .path.path }}'
 helm:
 valueFiles:
 - values.yaml
 destination:
 server: 'https://kubernetes.default.svc'
 namespace: '{{ .path.basename }}'
 syncPolicy:
 automated:
 prune: true
 selfHeal: true
 syncOptions:
 - CreateNamespace=true
 - ServerSideApply=true

The downside to this, however, is all applications from this applicationset will inherit this value, which is less than ideal.

Kubernetes on RK1 / Turing Pi 2: Automation with Ansible, Cilium and Cert-Manager

Fri, 30 Aug 2024 00:00:00 +0000

TLDR: Take me to the Playbook

Note - This is just a high-level overview, I’ll likely follow up with a post dedicated on the CIlium/BGP configuration.

I’ve had my Turing Pi 2 board for a while now, and during that time I’ve struggled to decide which automation tooling to use to bootstrap K3s to it. However, I reached a decision to use Ansible. It’s not something I’m overly familiar with, but this would provide a good opportunity to learn by doing.

eBPF + Grafana Live for Metric Streaming

Mon, 15 Apr 2024 00:00:00 +0000

Code Repo for this post can be found here.

Grafana Live is a real-time messaging engine built into Grafana v8 and onwards, designed to support real-time data streaming and updates. It allows data to be pushed to objects such as dashboard panels directly from the source. One of the benefits being near instant updates and no need to perform periodic refreshes.

Having experimented with eBPF recently, I thought this would be a neat thing to pair up - High performance packet analysis provided by Express Data Path (XDP), with instant visualisation provided by Grafana

Thursday Tech Tidbits - Fedora Silverblue, Podman and vscode Flatpak

Thu, 28 Mar 2024 00:00:00 +0000

Recently, I’ve started to embrace Fedora Silverblue (an immutable desktop OS) as my daily driver. One of the issues I encountered was trying to get my vscode (flatpak) to leverage remote containers via podman for development.

The following steps are fairly well documented to get started:

flatpak install com.visualstudio.code
flatpak install com.visualstudio.code.tool.podman
Set "dev.containers.dockerPath": "podman-remote" in VSCode settings/json:

However, these following (mandatory) steps took a bit more digging around. In a repo’s .devcontainer.json file, add:

Replicating my vSphere network configuration in Openshift Virtualisation

Mon, 05 Feb 2024 00:00:00 +0000

Red Hat Openshift Virtualisation provides a platform for running and managing Virtual Machines alongside Containers using a consistent API. It also provides a mechanism for migrating VMs from platforms such as vSphere.

As I have both environments, I wanted to deploy an Openshift Virtualisation setup that mimics my current vSphere setup so I could migrate Virtual Machines to it.

Existing vSphere Design

Below is a diagram depicting my current vSphere setup. My ESXi hosts are dual-homed with a separation of management (vmkernel) and virtual machine traffic.

Diving into an eBPF + Go Example: Part 1

Wed, 24 Jan 2024 00:00:00 +0000

Part 1 / Part 2 / Part 3

Preamble: In preparation for writing this I looked at some excellent content created by Liz Rice and Daniel Finneran - including videos, code and literature. I highly recommend checking out their work.

The Cilium eBPF documentation has some excellent examples of getting started with eBPF and Go. As a “hobbyist” programmer, I wanted to cement some of these concepts by digging deeper into one of the examples. Part of my learning style is to compile my own notes on a given topic, and this post is essentially that.

Diving into an eBPF + Go Example: Part 3 (Bonus Round)

Wed, 24 Jan 2024 00:00:00 +0000

Part 1 / Part 2 / Part 3

With one example explored, I wanted to put a spin on it - Therefore, I had an idea:

“Can I use eBPF to identify and store the contents of the protocol header for IP packets on a specific interface?”

It’s more of a rhetorical question - of course we can! The code can be found here.

To summarise, the eBPF C program is a little more complicated. It still leverages XDP, however instead of counting the number of packets, it will inspect each IP packet, extract the protocol number, and store it in a map.

Diving into an eBPF + Go Example: Part 2

Tue, 23 Jan 2024 00:00:00 +0000

Part 1 / Part 2 / Part 3

In Part 1, we had a look at creating the eBPF program in C, which we will need to compile into eBPF bytecode and inject into our Go application

Rather than copy/paste the exact instructions, the ebpf-go documentation outlines the process in the toolchain to create the scaffolding for the Go application.

package main

import (
 "log"
 "net"
 "os"
 "os/signal"
 "time"

 "github.com/cilium/ebpf/link"
 "github.com/cilium/ebpf/rlimit"
)

func main() {
 // Remove resource limits for kernels <5.11.
 if err := rlimit.RemoveMemlock(); err != nil {
 log.Fatal("Removing memlock:", err)
 }

 // Load the compiled eBPF ELF and load it into the kernel.
 var objs counterObjects
 if err := loadCounterObjects(&objs, nil); err != nil {
 log.Fatal("Loading eBPF objects:", err)
 }
 defer objs.Close()

 ifname := "eth0" // Change this to an interface on your machine.
 iface, err := net.InterfaceByName(ifname)
 if err != nil {
 log.Fatalf("Getting interface %s: %s", ifname, err)
 }

 // Attach count_packets to the network interface.
 link, err := link.AttachXDP(link.XDPOptions{
 Program: objs.CountPackets,
 Interface: iface.Index,
 })
 if err != nil {
 log.Fatal("Attaching XDP:", err)
 }
 defer link.Close()

 log.Printf("Counting incoming packets on %s..", ifname)

 // Periodically fetch the packet counter from PktCount,
 // exit the program when interrupted.
 tick := time.Tick(time.Second)
 stop := make(chan os.Signal, 5)
 signal.Notify(stop, os.Interrupt)
 for {
 select {
 case <-tick:
 var count uint64
 err := objs.PktCount.Lookup(uint32(0), &count)
 if err != nil {
 log.Fatal("Map lookup:", err)
 }
 log.Printf("Received %d packets", count)
 case <-stop:
 log.Print("Received signal, exiting..")
 return
 }
 }
}

As there’s already an example, let’s dig into the prominent sections:

Changing the default apps wildcard certificate in OCP4

Sat, 30 Dec 2023 00:00:00 +0000

In a standard OCP4 installation, several route objects are created by default and secured with a internally signed wildcard certificate.

These routes are configured as <app-name>.apps.<domain>. In my example, I have a cluster with the assigned domain ocp-acm.virtualthoughts.co.uk, which results in the routes below:

oauth-openshift.apps.ocp-acm.virtualthoughts.co.uk
console-openshift-console.apps.ocp-acm.virtualthoughts.co.uk
grafana-openshift-monitoring.apps.ocp-acm.virtualthoughts.co.uk
thanos-querier-openshift-monitoring.apps.ocp-acm.virtualthoughts.co.uk
prometheus-k8s-openshift-monitoring.apps.ocp-acm.virtualthoughts.co.uk
alertmanager-main-openshift-monitoring.apps.ocp-acm.virtualthoughts.co.uk

Inspecting console-openshift-console.apps.ocp-acm.virtualthoughts.co.uk shows us the default wildcard TLS certificate used by the Ingress Operator:

Because it’s internally signed, it’s not trusted by default by external clients. However, this can be changed.

Improving the CI/build process for the community Rancher Exporter

Mon, 05 Jun 2023 00:00:00 +0000

One of my side projects is developing and maintaining an unofficial Prometheus Exporter for Rancher. It exposes metrics pertaining to Rancher-specific resources including, but not limited to managed clusters, Kubernetes versions, and more. Below shows an example dashboard based on these metrics.

Incidentally, if you are using Rancher, I’d love to hear your thoughts/feedback.

Previous CI workflow

The flowchart below outlines the existing process. Whilst automated, pushing directly to latest is bad practice.

Simplify Multus deployments with Rancher and RKE2

Mon, 08 May 2023 00:00:00 +0000

From my experience, some environments necessitate leveraging multiple NICs on Kubernetes worker nodes as well as the underlying Pods. Because of this, I wanted to create a test environment to experiment with this kind of setup. Although more common in bare metal environments, I’ll create a virtualised equivalent.

Planning

This is what I have in mind:

In RKE2 vernacular, we refer to nodes that assume etcd and/or control plane roles as servers, and worker nodes as agents.

Debugging cloud-init not executing runcmd commands

Wed, 18 Jan 2023 00:00:00 +0000

Background

Rancher leverages cloud-init for the provisioning of Virtual Machines on a number of infrastructure providers, as below:

I recently encountered an issue whereby vSphere based clusters using an Ubuntu VM template would successfully provision, but SLES based VM templates would not.

What does Rancher use cloud-init for?

This is covered in the Masterclass session I co-hosted, but as a refresher, particularly with the vSphere driver, Rancher will mount an ISO image to the VM to deliver the user-data portion of a cloud-init configuration. The contents of which look like this:

Installing & Using the Nvidia GPU Operator in K3s with Rancher

Mon, 21 Nov 2022 00:00:00 +0000

This post outlines the necessary steps to leverage the Nvidia GPU operator in a K3s cluster. In this example, using a gift from me to my homelab, a cheap Nvidia T400 GPU which is on the supported list for the operator.

Step 1 - Configure Passthrough (If required)

For this environment, vSphere is used and therefore PCI Passthrough is required to present the GPU to the VM. The Nvidia GPU is represented as two devices - one for the video controller, and another for the audio controller - we only need the video controller. Steps after this are still relevant to bare metal deployments.

Using the NSX-T CNI with RKE2

Mon, 04 Jul 2022 00:00:00 +0000

This post outlines the necessary steps to leverage the VMware NSX-T CNI with RKE2

1. Planning

The following illustrates my Lab environment with a single node cluster:

General Considerations

If you have a new NSX-T environment, ensure you have (as a minimum) the following:

T0 Router
T1 Router
Edge Cluster
VLAN Transport Zone
Overlay Transport Zone
Route advertisement (BGP/OSPF) to the physical network

NSX Specific Considerations

A network segment (or vds port) for management traffic (NS-K8S-MGMT in this example)
A network segment for overlay traffic (NS-K8S-OVERLAY)

Management traffic should be put on a routed network
Overlay traffic does not have to be on a routed network

Evaluating Harvester in vSphere

Mon, 20 Dec 2021 00:00:00 +0000

Disclaimer - The use of nested virtualisation is not a supported topology

Harvester is an open-source HCI solution aimed at managing Virtual Machines, similar to vSphere and Nutanix, with key differences including (but not limited to):

Fully Open Source
Leveraging Kubernetes-native technologies
Integration with Rancher

Testing/evaluating any hyperconverged solution can be difficult - It usually requires having dedicated hardware as these solutions are designed to work directly on bare metal. However, we can circumvent this by leveraging nested virtualisation - something which may be familiar with a lot of homelabbers (myself included) - which involves using an existing virtualisation solution provision workloads that also leverage virtualisation technology.

Taking a Modular Approach to my Homelab with Pulumi

Wed, 17 Nov 2021 00:00:00 +0000

Architecture

After reviewing the key components of my lab environment, I translated these into the Pulumi stacks as illustrated in the diagram below. Pulumi has a blog post about the benefits of adopting multiple stacks and I found organising my homelab this way enables greater flexibility and organisation. I can also use stacks as a “template” to further build out my lab environment, for example, repeating the “Tools-Cluster” stack to add additional clusters.

Creating Kubernetes Clusters with Rancher and Pulumi

Thu, 13 May 2021 00:00:00 +0000

tldr; Here is the code repo

Intro

My Job at Suse (via Rancher) involves hosting a lot of demos, product walk-throughs and various other activities that necessitate spinning up tailored environments on-demand. To facilitate this, I previously leaned towards Terraform, and have since curated a list of individual scripts I have to manage on an individual basis as they address a specific use case.

This approach reached a point where it became difficult to manage. Ideally, I wanted an IaC environment that catered for:

Writing my first Prometheus exporter and scraping with Rancher

Mon, 03 May 2021 00:00:00 +0000

TLDR; Code repo can be found here. Huge thanks to Spencer for the original blog post that helped me, answering some questions over email, and providing a really helpful Prometheus exporter template (in Go) that I used for this example.

The monitoring framework in Rancher 2.5 was significantly changed - including, but not limited to, giving us the ability to scrape for our own application metrics and creating custom Grafana dashboards. The Monitoring stack in Rancher is a culmination of a number of open-source technologies:

K3s, Rancher and Pulumi

Tue, 06 Apr 2021 00:00:00 +0000

TLDR; Repo can be found here (Be warned, I’m at best, a hobbyist programmer and certainly not a software engineer in my day job)

I’ve been recently getting acquainted with Pulumi as an alternative to Terraform for managing my infrastructure. I decided to create a repo that would do a number of activities to stand up Rancher in a new K3s cluster, all managed by Pulumi in my vSphere Homelab, consisting of the following activities:

Automated deployment of K3s and Rancher on vSphere with Terraform

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

Previously, my local Rancher installs were based on RKE. However, since K3S is now a supported distribution, I decided to rebuild my environment leveraging it. Additionally, it was a good opportunity to automate the process with Terraform.

TL;DR

https://github.com/David-VTUK/Rancher-K3s-vSphere contains the Terraform code required to do this.

Quick note on K3S with Embedded DB

This installation method is currently experimental. Do not leverage it in production (yet). Towards the end of August 2020, we (Rancher) plan to replace it with embedded etcd as per the roadmap. I’m a fan of simplicity, therefore when v1.19 does come out, I plan to simply tear down and rebuild my cluster using this Terraform code. However, one could equally modify it to leverage an external DB for a more production-ready setup.

End to end automation with CircleCI and ArgoCD Part 1 - Overview

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

Part 1 of this 3 part series goes through the process of setting up a CI/CD pipeline leveraging CircleCI and ArgoCD. The overall architecture is depicted below:

CI/CD Delivery Pipeline

The steps that will be implemented/accommodated are:

Developer commits code to a GitHub repo that is monitored by CircleCI.
CircleCI will perform the following tasks on all commits into the master branch:
1. Test the code. In this example, we’re leveraging go test.
2. If Testing completes successfully, build (compile) the code.
3. If building the code completes successfully, construct a docker image to accommodate the service. Push this image to DockerHub
4. If creating the Docker Image completes successfully, construct a basic deployment YAML file including the tag of the image that was recently uploaded.
5. Commit the YAML file to a separate GitHub repo, monitored by ArgoCD.
Argo CD will deploy the YAML manifest:
1. Automatically into the Test cluster
2. With manual approval into the Prod cluster

Part 2 - CircleCI Configuration

End to end automation with CircleCI and ArgoCD Part 2 - CircleCI Configuration

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

CircleCI is a continuous integration technology that is capable of building extremely complex pipelines. Being cloud-hosted and offering a free tier makes it very easy to get up and running.

Simply navigate to CircleCI’s website and log in with either Github or Bitbucket.

Select your org:

Select your project. For me, it’s CircleCI-Webapp-CI (Feel free to fork it or leverage your own)

The next step is to create a CircleCI config file that will dictate the steps in the pipeline. CircleCI provides a template to work with:

End to end automation with CircleCI and ArgoCD Part 3 – ArgoCD

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

ArgoCD is a Continuous Delivery tool designed for Kubernetes, This will be used to take the generated YAML file from the CI process and apply it to two clusters.

In this section, the following part of the overall CI/CD pipeline being implemented is depicted below.

ArgoCD will monitor for changes in the Webapp-CD Github Repo.
All changes are automatically applied to the Test cluster.
All changes will be staged for manual approval to Prod cluster

Install ArgoCD

ArgoCD has extensive installation documentation here. For ease, a community Helm chart has also been created.

Rancher, vSphere Network Protocol Profiles and static IP addresses for k8s nodes [Updated 2023]

Sun, 29 Mar 2020 00:00:00 +0000

Edit: This post has been updated to reflect changes in newer versions of Rancher.

Note: As mentioned by Jonathan in the comments, disabling cloud-init’s initial network configuration is recommended. To do this, create a file:

/etc/cloud/cloud.cfg.d/99-disable-network-config.cfg

To contain:

network: {config: disabled}

In your VM template.

How networking configuration is applied to k8s nodes (or VM’s in general) in on-premises environments is usually achieved by one of two ways - DHCP or static. For some, DHCP is not a popular option and static addresses can be time-consuming to manage, particularly when there’s no IPAM feature in Rancher. In this blog post I go through how to leverage vSphere Network Protocol Profiles in conjunction with Rancher and Cloud-Init to reliably, and predictably apply static IP addresses to deployed nodes.

K3S and Nvidia Jetson Nano

Tue, 24 Mar 2020 00:00:00 +0000

K3S is a lightweight Kubernetes distribution developed by Rancher Labs, perfect for Edge Computing use cases where compute resources may be somewhat limited. It supports x86_64, ARMv7, and ARM64 architectures.

Ok, why the Nvidia Nano?

Deploying Kubernetes, be it K8s, K3s or otherwise is fairly well documented on devices such as the Raspberry Pi, however, I wanted to have an attempt doing so on a Nano for the GPU capabilities, which might be beneficial with ML/AI workloads.

On-prem K8s clusters with Rancher, Terraform and Ubuntu

Fri, 27 Dec 2019 00:00:00 +0000

One of the attractive characteristics of Kubernetes is how it can run pretty much anywhere - in the cloud, in the data center, on the edge, on your local machine and much more. Leveraging existing investments in datacenter resources can be logical when deciding where to place new Kubernetes clusters, and this post goes into automating this with Rancher and Terraform.

Primer

For this exercise the following is leveraged:

Rancher 2.3
vSphere 6.7
Ubuntu 18.04 LTS

An Ubuntu VM will be created and configured into a template to spin up Kubernetes nodes.

Pi-Hole and K8s v2 - Now with DNS over HTTPS

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

In a previous post, I went through the process of configuring Pi-Hole within a Kubernetes cluster for the purpose of facilitating a network-wide adblocking. Although helpful, I wanted to augment this with DNS over HTTPS.

Complete manifests can be found here. Shout out to visibilityspots for the cloudflared image on Dockerhub

Why?

DNS, as a protocol, is insecure and can be prone to manipulation and man-in-the-middle attacks. DNS over HTTPS helps address this by encrypting the data between the DNS over HTTPS client and the DNS over HTTPS-based DNS resolver. One of which is provided by Cloudflare.

K8s, MetalLB and Pihole

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

An ongoing project of mine involves the migration of home services (Unifi, Pi-hole, etc) to my Kubernetes cluster. This post explores my approach to migrating Pi-hole, with the help of MetalLB.

MetalLB Overview

MetalLB is a load balancer implementation for environments that do not natively provide this functionality. For example, with AWS, Azure, GCP and others, provisioning a “LoadBalancer” service will make API calls to the respective cloud provider to provision a load balancer. For bare-metal / on-premises and similar environments this may not work (depending on the CNI used). MetalLB bridges this functionality to these environments so services can be exposed externally.

Creating a highly available, cross AZ, loadbalanced ETCD cluster in AWS with Terraform

Sun, 08 Sep 2019 00:00:00 +0000

Having experimented with Terraform recently, I decided to leverage this tool by creating an etcd cluster in AWS. This blog post goes through the steps used to accomplish this. For readability, I’ve only quoted pertinent code snippets, but all of the code can be found at https://github.com/David-VTUK/terraformec2.

Disclaimer

I do not profess to be an Etcd, Terraform or AWS expert, therefore he be dragons in the form of implementations unlikely to be best practice or production-ready. In particular, I would like to revisit this at some point and enhance it to include:

Application security with mutual TLS (mTLS) via Istio

Mon, 15 Jul 2019 00:00:00 +0000

TLS Overview

If we take an example of accessing a website such as https://www.virtualthoughts.co.uk/, these are the high-level steps of what occurs:

The client initiates a connection to the web server requesting an HTTPS connection.
The web server responds with its public key. The client validates the key with its list of known Certificate Authorities.
A session key is generated by the client and encrypted with the web server’s public key and is sent back to the web server.
The web server decrypts the session key with its private key. End to end encryption is established.

By default, the TLS protocol only proves the identity of the server to the client using X.509 certificate and the authentication of the client to the server is left to the application layer. For external, public-facing websites, this is an acceptable and well-established implementation of TLS. But what about communication between different microservices?

Container Packet Inspection with NSX-T

Wed, 10 Jul 2019 00:00:00 +0000

For troubleshooting (or just being a bit nosey) we have a number of tools that allow us to inspect the traffic between two endpoints. When it comes to containers however, our approach has to be adjusted slightly. When using NSX-T as a CNI, we have some of these tools available to us out of the box.

App Overview

For this example, I’ve deployed a standard Wordpress deployment consisting of a frontend (web) pod and a backend (DB) pod. The objective is to identify and capture the traffic between these pods.

Step by Step - Istio up and running

Sun, 23 Jun 2019 00:00:00 +0000

Service Mesh is a pretty hot topic in the Kubernetes ecosystem currently, and I wanted to get it up and running in my own lab environment. Istio’s documentation has a pre-baked solution to demonstrate some of its capabilities (a book app, if memory serves me correctly), but I wanted to deploy my own app to get more “hands-on” experience with the tech, even if it’s only very basic to start with.

Removing Unused PKS LoadBalancer IP allocations in NSX-T

Fri, 21 Jun 2019 00:00:00 +0000

I’m constantly building, removing, destroying, breaking and constantly tinkering in my lab, which unfortunately can leave behind a bit of technical mess. Most recently I’ve been doing some messing around in PKS and consequently had a load of load balancer VIPs no longer in use due to clusters being destroyed and / or recreated.

Unfortunately, there’s no way to remove these in the UI (for now, at least). But you can remove them using the API.:

Introducing Velero - Backup and DR for Kubernetes Applications

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

What is Velero?

Velero (previously known as Heptio ARK) provides a suite of tools to backup Kubernetes resources and applications for two main purposes:

Disaster Recovery - Recover Kubernetes cluster components and applications.
Migration - Migrate your Kubernetes applications to another Kubernetes cluster.

Migrating Kubernetes applications is a compelling use case. One of the significant benefits of using Kubernetes is the predictability of the platform and consequently the portability of applications that reside on it. With the main exception of nuances with persistent storage, the Kubernetes API will fell almost indistinguishable whether it resides on prem, GKE, AKS, EKS and elsewhere. If you have your Kubernetes-based application on one provider and want to migrate it to another or duplicate it to run elsewhere for dev/test, this can easily be achieved. Especially with Velero.

Bootstrapping Prometheus, Grafana and Alertmanager to PKS deployed K8s Clusters

Tue, 14 May 2019 00:00:00 +0000

PKS is a comprehensive platform for the provisioning and management of Kubernetes clusters, which can be further enhanced by leveraging its extensibility options. In this post, we will modify a plan to deploy a yaml manifest file which provisions Prometheus, Grafana, and Alertmanager backed by NSX-T load balancers.

Why Prometheus, Grafana and Alertmanager?

The Cloud Native Computing Foundation accepted Prometheus as its second incubated project, the first being Kubernetes. Originally developed by SoundCloud. It has quickly become a popular platform for the monitoring of Kubernetes platforms. Built upon a powerful analytics engine, extensive and highly flexible data modeling can be accomplished with relative ease.

CKA Exam Experience (Inc study & lab guide)

Tue, 07 May 2019 00:00:00 +0000

Introduction

Over the long bank holiday weekend, I sat and passed the Certified Kubernetes Exam (CKA). This blog post goes over my experience (With respect to the NDA) together with a lab guide I’ve made which I’ve uploaded hoping it might help others.

Format

The online exams consist of a set of performance-based items (problems) to be solved on the command line. For the CKA there are 24 questions of varying difficulty. At the time of writing, the only option to sit this exam is through remote proctoring.

Exposing the K8s dashboard via a NSX-T Load balancer

Mon, 15 Apr 2019 00:00:00 +0000

For the following to work, your k8s infrastructure needs to leverage some kind of CNI that’s able to provision load balancers. For this example I’m leveraging PKS which has native integration with NSX-T.

The default way to access the Kubernetes dashboard is to leverage the kubectl proxy command. However, this is somewhat limiting for a production environment. An alternative way is to expose the dashboard through a load balancer.

PKS, Harbor and the importance of container registries

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

What are container registries and why do we need them?

A lot of the time, particularly when individuals and organisations are evaluating, testing and experimenting with containers they will use public container registries such as Docker Hub. These public registries provide an easy-to-use, simple way to access images. As developers, application owners, system admins etc gain familiarity and experience additional operational considerations need to be explored, such as:

Organisation - How can we organise container images in a meaningful way? Such as by environment state (Prod/Dev/Test) and application type?
RBAC - How can we implement role-based access control to a container registry?
Vulnerability Scanning - How can we scan container images for known vulnerabilities?
Efficiency - How can we centrally manage all our container images and deploy an application from them?
Security - Some images need to kept under lock and key, rather than using an external service like Docker Hub.

Introducing VMware Harbor Registry

VMware Harbor Registry has been designed to address these considerations as enterprise-class container registry solution with integration into PKS. In this post, We’ll have a quick primer on getting up and running with Harbor in PKS and explore some of its features. To begin, we need to download PKS Harbor from the Pivotal site and import it into ops manager.

Efficiency gains from small(er) containers

Mon, 11 Feb 2019 00:00:00 +0000

Preamble

A lot of organisations are looking towards containerising their applications and embracing the world of microservices. There are a number of ways to reach this goal, through a variety of tools and methodologies, this blog post goes through one way of approaching this task.

In a previous blog post I went through the process of taking a web application and putting it into a container, and whilst it got the job done, there wasn’t a lot of attention given to the image used for the container. So let’s address that.

vRealize Log Insight + PKS Integration

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

Introduction

In this blog post, we take a look into the integration between PKS and vRealize Log Insight and how this integration benefits the enterprise. As a bit of a recap:

PKS - PKS is a purpose-built enterprise level container solution leveraging the capabilities of Kubernetes, BOSH, VMware NSX-T, Harbour and more to deliver a highly available, highly flexible container runtime that operates on a number of cloud platforms, both private and public, including vSphere, AWS, Azure and GCP.

My VCAP6-NV Experience

Tue, 18 Sep 2018 00:00:00 +0000

Preamble (pun intended)

I’ve been eyeing up the VCAP6-NV exam for quite some time now, but due to work and personal projects I’ve not been able to focus on this exam. Having some time between jobs I decided to start revising and push myself into taking the exam. At time of writing, there is still no NV-Design exam, therefore, anyone who sits and passes the VCAP6-NV Deploy exam is automatically given the VCIX6-NV certification.

NSX-T, Kubernetes and Microsegmentation

Wed, 01 Aug 2018 00:00:00 +0000

For the uninitiated, VMware NSX comes in two “flavours”, NSX-V which is heavily integrated with vSphere, and NSX-T which is more IaaS agnostic. NSX-T also has more emphasis on facilitating container-based applications, providing a number of features into our container ecosystem. In this blog post, we discuss the microsegmentation capabilities provided by NSX-T in combination with container technology.

What is Microsegmentation?

Prior to Software-defined networking, firewall functions were largely centralised, typically manifested as edge devices which were and still are, good for controlling traffic to and from the datacenter, otherwise known as north-south traffic:

Kubernetes zero to hero - from single VM webserver to a scalable microservices infrastructure

Fri, 13 Jul 2018 00:00:00 +0000

Preamble

Having spent a number of months familiarising myself with container technology I inevitably got “stuck in” with Kubernetes. Containers are brilliant, but I personally don’t see the value of managing individual containers - it’s still the pets vs cattle mentality. Orchestrating containers with the likes of Kubernetes, however, makes a ton of sense and reinforces the microservices approach to building and deploying applications.

To test myself, I decided to document end-to-end the entire journey from taking a web server residing on a standalone virtual machine, containerise it, and deploying it via Kubernetes.

Introducing VMware Kubernetes Engine

Wed, 27 Jun 2018 00:00:00 +0000

On the 26th of June 2018, VMware publically announced VKE - VMware Kubernetes Engine in Beta (with GA planned for later on this year). For me, the development of this solution flew under the radar, and its subsequent release came as quite a surprise - albeit quite a good one. So, where exactly does this solution fit with other Kubernetes based solutions that currently exist?

VKE Overview

VKE sits within VMware’s portfolio of cloud-native solutions as is pitched as a fully managed, Kubernetes-as-a-service offering. Therefore we have multiple ways we can consume Kubernetes resources from the VMware ecosystem, depicted in the diagram below.

Hybrid Cloud monitoring with VMware vRealize Operations

Tue, 12 Jun 2018 00:00:00 +0000

Applications and the underlying infrastructure, be it public, private or hybrid cloud are becoming increasingly sophisticated. Because of this, the way in which we monitor and observe these environments requires more sophisticated tools. In this blog post, we look at vRealize Operations and how it can be a facilitator of true hybrid cloud monitoring.

What is vRealize Operations?

vRealize Operations forms part of the overall vRealize suite from VMware – a collection of products targeted to accommodate cloud management and automation. In particular, vRealize Operations, as the name implies, primarily caters to operations management with full visibility across physical, virtual and cloud-based environments. The anatomy of vRealize Operations is depicted below

GCP Kubernetes & VMware Wavefront - a practical demonstration

Mon, 04 Jun 2018 00:00:00 +0000

Wavefront

Back in 2017, VMware acquired Wavefront - a company based in the US which focuses predominantly on real-time metrics and monitoring of a really…really vast array of platforms and technologies. We have technologies that aid in adopting and promoting cloud-native implementations, but monitoring, in some peoples eyes, can be a bit of an afterthought. Wavefront to the rescue. Having developed some Kubernetes and Docker knowledge myself, it seemed rather fitting to get an example going.

Introducing the vSAN Driver for Docker

Sat, 19 May 2018 00:00:00 +0000

The persistent storage requirement for the container ecosystem

When we talk about containers we generally think about microservices and all things ephemeral. But does this mean that we can’t facilitate stateful workloads leverage persistent storage? Absolutely not.

In the docker world, we choose a storage “driver” to back our persistent storage onto. The driver we choose is based on a number of requirements and which operating system our Docker hosts run. The table below lists the recommended out-of-the-box drivers for Docker Community Edition.

Serverless and Containers - from a former ops guy

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

Post-AWS Summit 2018 Thoughts on Serverless and Containers

I was lucky enough to attend the AWS summit in London in May 2018. It was a first for me, and the experience was pretty awesome. With a veritable smorgasbord of chalk talks, instructor-led demos and vendor presence there was something for everyone. I gravitated towards the docker/lambda sessions as I had recently picked up learning container technology, which got me thinking - from my perspective (previous ops-centric), how does container technology compare to the likes of serverless? When would you use one over the other? Whilst on the train home from London I decided to jot down my notes into this post.

vSphere and Containers part 1 - VIC (VMware Integrated Containers)

Wed, 28 Mar 2018 00:00:00 +0000

In this multi-part series, we evaluate the options available to vSphere users/customers wishing to deploy a native container service into an existing vSphere environment.

Part 1 - VIC (VMware Integrated Containers).

Part 2 - PKS (Pivotal Container Service).

Why should we care about containers?

Containers change the way we fundamentally look at application deployment and development. There was a huge shift in the way we managed platforms when server virtualisation came around - all of a sudden we had greater levels of flexibility, elasticity and redundancy compared to physical implementations. Consequently, the way in which applications were developed and deployed changed. And here we are again, with the next step of innovation using technology that is making rifts in the industry, changing the way consume resources.

My Technology Hitlist for 2018

Tue, 27 Mar 2018 00:00:00 +0000

It’s time for me to set a few objectives with which technologies I want to learn more about in 2018. As a reminder for me and to try and not lose focus, I’ve compiled it into a blog post.

vRealize Automation / Orchestration

I’ve always dabbled in automation and orchestration but never really gone “full on”. I used to write a lot of scripts for migrations and such “back in the day”, so I’ll be looking forward to getting my hands dirty again and messing around with automating and orchestrating….all the things.

Understanding Data Center traffic flow using NSX-V capabilities

Fri, 02 Mar 2018 00:00:00 +0000

The defining characteristic of the Software Defined Data Center (SDDC), as the name implies, is to bring the intelligence and operations of various datacenter functions into software. This type of integration provides us with the ability to gain insights and analytics in a much more controlled, tightly integrated fashion.

VMware NSX is the market leader in network virtualisation. In this post, we have a look at a selection of tools which come with NSX, enabling a greater understanding of exactly what is transpiring in our NSX environment.

vRealize Log insight – Frequently Overlooked Centralised Log Management

Mon, 15 Jan 2018 00:00:00 +0000

Log analysis has always been a standardised practice for activities such as root cause analysis or advanced troubleshooting. However, ingesting and analysing these logs from different devices, types, locations and formats can be a challenge. In this post, we have a look at vRealize Log Insight and what it can deliver.

What is it?

vRealize Log Insight is a product in the vRealize suite specifically designed for heterogeneous and scalable log management across physical, virtual and cloud-based environments. It is designed to be agnostic across what it can ingest logs from and is therefore valid candidate in a lot of deployments.

Homelab Networking Refresh

Mon, 18 Dec 2017 00:00:00 +0000

Adios, Netgear router

In hindsight, I shouldn’t have bought a Netgear D7000 router. The reviews were good but after about 6 months of ownership, it decided to exhibit some pretty awful symptoms. One of which was completely and indiscriminately drop all wireless clients regardless of device type, range, band or frequency it resided on. A reconnect to the wireless network would prompt the passphrase again, weirdly. Even after putting in the passphrase (again) it wouldn’t connect. The only way to rectify this was to physically reboot the router.

Embracing the SDDC with NSX-V automation

Mon, 11 Dec 2017 00:00:00 +0000

The Software Defined Data Center (SDDC for short) has become a widely adopted and embraced model for modern datacentre implementations. Conveying the benefits of the SDDC, particularly the non-technical aspects can be a challenge. In this blog post we take a practical example of a single activity we can automate in NSX and the benefits that come from it, both technical and non-technical.

The NSX API

An API (Application Programming Interface), in simple terms is an intermediary that allows two applications to communicate with each other via a common syntax. Although we may not be aware of it, it’s likely we use API’s every day when we use applications such as Facebook, LinkedIn, vSphere and countless others. For example, when you create a logical switch in the vSphere web client, behind the scenes an API call is made to the NSX manager to facilitate that request.

VMware Cloud on AWS

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

Perhaps one of VMware’s most significant announcements made in recent times is the partnership with Amazon Web Services (AWS), including the ability to leverage AWS’s infrastructure to provision vSphere managed resources. What exactly does this mean and what benefits could this bring to the enterprise?

Collaboration of Two Giants

To understand and appreciate the significance of this partnership we must acknowledge the position and perspective of each.

Market leader in private cloud offerings
Deep roots and history in virtualisation
Expanding portfolio

Joining the Insight Team

Thu, 02 Nov 2017 00:00:00 +0000

As of this week, I started a new position at Insight as a VMware/SDDC Solutions Architect/Evangelist. Exciting times!

I’ll be fortunate to work with the likes of established community contributors and experts in the field such as vJenner and Chan.

Why Insight?

The IT landscape is constantly changing and with it, we as IT professionals must adapt accordingly. I wanted a new challenge, to expand my horizons and delve deeper into the areas I’ve already gained experience in. Insight is such a place that will allow me to do this. My new boss described it quite eloquently: “We sell everything to everyone”. This doesn’t mean that Insight will push for subpar products though - part of the philosophy here is that we’re transparent, flexible and agnostic. Leading solutions are evaluated and assessed to address a plethora of challenges presented by both existing and new customers. Multiple vendors, multiple products, private/public/hybrid cloud and everything in-between is considered as part of the product/solutions/services portfolio.

VMware vRealize Operations 2017 Specialist Exam (2VB-602)

Sun, 15 Oct 2017 00:00:00 +0000

“Specialist Exams”….Wait, what?

I have a requirement to essentially get more up to speed with vRealize Operations Manager. As I was digging through some of the reading material I came across the specialist exam. The details for which can be found here.

I wasn’t actually aware up until this point VMware actually offer specialist exams. At time of writing vRealize Operations and vSAN are the only two specialist certifications you can take.

NSX Livefire Course

Wed, 04 Oct 2017 00:00:00 +0000

Recently I was lucky enough to attend a NSX livefire course hosted at the VMware EMEA HQ in Staines, It’s designed to facilitate a intensive knowledge transfer of NSX related subject matter. All participants are bound by NDA, however most of the information is GA with the exception of roadmap information.

Day One

Day one was focused on introducing all the participants, laying a foundation for the course objectives as well as some background info on NSX. In addition the following topics were covered:

Homelab - Nested ESXi with NSX and vSAN

Tue, 03 Oct 2017 00:00:00 +0000

The Rebuild

I decided to trash and rebuild my nested homelab to include both NSX and vSAN. When I attempted to prepare the hosts for NSX I received the following message:

I’ve not had this issue before so I conducted some research. I found a lot of blog posts / comments / KB articles linking this issue to VUM. For example : https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=2053782

However, after following the instructions I couldn’t set the “bypassVumEnabled” setting. Nor could I manually install the NSX vibs and was presented with the following:

vDS to vSS and back again

Sun, 02 Jul 2017 00:00:00 +0000

Overview

I was recently tasked with migrating a selection of ESXi 5.5 hosts into a new vSphere 6.5 environment. These hosts leveraged Fibre Channel HBA’s for block storage and 2x10Gbe interfaces for all other traffic types. I assumed that doing a vDS detach and resync was not the correct approach to do this, even though some people reported success doing it this way. The /r/vmware Reddit community agreed and later I found a VMware KB article that backs the more widely accepted solution involving moving everything to a vSphere Standard Switch first.

Intel Skylake/Kaby Lake processors: broken hyper-threading

Mon, 26 Jun 2017 00:00:00 +0000

Overview

Source : https://lists.debian.org/debian-devel/2017/06/msg00308.html

It appears some Intel Xeon CPU’s are susceptible to a recently discovered Hyper Threading bug. However, these are limited to E3 v5/v6 based Xeon systems which are found mostly in entry level servers with single socket implementations. > Dual socket systems currently leverage E5 based Xeons which don’t appear to be affected.

Currently, the easiest way to mitigate against this bug is to simply disable hyper-threading. The bug also appears to be OS agnostic.

Homelab v2 - Part 1

Fri, 19 May 2017 00:00:00 +0000

Out with the old

My previous homelab, although functional was starting to hit the limits of 32GB of RAM, particularly when running vCenter, vSAN, NSX, etc concurrently.

A family member had use for my old lab so I decided to sell it and get a replacement whitebox.

Requirements

Quiet - As this would live in my office and powered on pretty much 24/7 it need a silent running machine
Power efficient - I’d rather not rack up the electric bill.
64GB Ram Support

VCAP6 Deploy Passed

Sat, 06 May 2017 00:00:00 +0000

Now I can rest…

I decided at around mid December to make passing the VCAP6 DCV Deploy exam a target. Today I can tick that objective off. As I have previously passed the VCAP5-DCD exam this should entitle me to the VCIX-DCV certification, but I may need to wait a bit for that.

My Experience

Precisely this time last year I passed the VCAP5-DCD exam. By cheer coincidence I picked exactly 365 days later to do the deploy exam on v6. I was quite nervous as I’ve never done a deploy VMware lab exam before. The lab itself was reasonably well laid out but the response times and general feel of the environment was a bit sluggish, but then again my home lab resides on SSD storage so perhaps I’m used to a snappy interface.

My Nested NSX Home Lab

Sun, 15 Jan 2017 00:00:00 +0000

With the ever growing popularity of SDDC solutions I’ve decided to invest some time in learning VMware NSX and sit the VCP6-NV Exam. For this I’ve re-purposed my existing homelab and configured it for NSX. I have a fairly simple setup consisting of a single whitebox “server” that will accommodate nested ESXi hypervisors and a HP Microserver acting as a iSCSI target.

Whitebox specs:

Motherboard: MSI B85M-E45 Socket 1150

CPU: Intel Core i7 4785T 35W TDP

VCP6-NV Study Materials

Fri, 18 Nov 2016 00:00:00 +0000

NSX is a very exciting technology and I’ve made it a personal goal to sit and (hopefully) pass the VCP6-NV Exam. I hear it’s a tough exam, so it should provide a good challenge.

In preparation for this my list of resources are as follows:

Plenty of experimenting in my homelab
VCP6-NV Official Cert guide from Amazon.co.uk
VMware NSX for vSphere Network Virtualization Design Guide

More resources will be added as I find them. To anyone else wishing to pass this exam - Good luck!

Achievement Unlocked : Dell Compellent Certified Deployment Professional

Thu, 11 Aug 2016 00:00:00 +0000

I’ve only recently started focusing more on developing my storage skills which I personally believe to be a good complement to my existing VMware knowledge. I’ve been working with Compellent systems for a few months now and thought it was a good time to get officially certified.

The exam itself put me a little out of my comfort zone, as in the past my storage level knowledge was limited to administrator level on EqualLogic setups. This exam was tough but rewarding.

An introduction to vSphere Metro Storage Cluster with Compellent Live Volume

Thu, 16 Jun 2016 00:00:00 +0000

Intro

VMware vSphere Metro Storage Cluster is a suite of infrastructure configurations that facilitate a stretched cluster setup. It’s not a feature like HA/DRS that we can switch on easily; it requires architectural design decisions that specifically contribute to this configuration. The foundation of which are stretched clusters and with regards to the Compellent suite of solutions Live Volume

Stretched Cluster

Stretched clusters are pretty much self explanatory. In comparison to a lot of configurations where compute clusters reside within the same physical room, stretched clusters spread the compute capacity over more than one physical location. This can still be internally (different server rooms within the same building) or further apart over geographically disperse sites.

Facilitating multi-SAN Environments

Mon, 23 May 2016 00:00:00 +0000

The what, where and why

At the moment I’m involved in a fair amount of project work involving data (VM) migrations between different storage platforms, sometimes even from the same vendor. What seems to be quite a simple process can get complicated depending on the design considerations for both storage platforms and the migration criteria - particularly if both storage platforms need to co-exist for either the short or long term and migrated VM’s must be performed live.

In-guest iSCSI to native VMDK

Thu, 05 May 2016 00:00:00 +0000

Do we really need in-guest iSCSI volumes?

Well, yes and no.

I’ll admit, the need for VM’s with their own iSCSI initiator have decreased over the various improvements made to vSphere and ESXi. However, I would imagine there are a number of implementations that (justifiably) still need this arrangement, and those that don’t. I was recently tasked with eliminating a number of guest-initiated iSCSI disks in favor of using native VMDK’s.

Hello World!

Mon, 02 May 2016 00:00:00 +0000

Nothing really special here. I plan on using this site to post on (what I believe to be interesting) topics that covers a number of technologies.

Enjoy.

VCAP5-DCD Experience

Mon, 02 May 2016 00:00:00 +0000

Motivation

Towards to end of 2015 I decided to make passing the VCAP5-DCD exam a target. I had already refreshed my VCP certification to version 6 and wanted to move further up VMware’s certification chain. It may have seen unusual timing giving the impending release of version 6 of the VCAP exams, but as I was in between jobs at the time it seemed like a good idea to not only demonstrate some additional skills, but enhance my CV for potential employers.

VCP6-NV Passed!

Sun, 01 May 2016 00:00:00 +0000

Motivation

SDDC solutions are becoming increasingly more popular, and although I’m probably a little biased, I would say that NSX is leading the software defined networking front. Following on from my previous post about my nested NSX homelab I sat and (thankfully passed) the VCP6-NV exam.

Study Materials

The official cert guide - https://www.amazon.co.uk/VCP6-NV-Official-2V0-641-Vmware-Certification/dp/0789754800/ref=sr_1_1?ie=UTF8&qid=1493819639&sr=8-1&keywords=vcp6-NV

Practice (non exam) questions - http://www.elasticsky.co.uk/practice-questions/

Blueprint - https://mylearn.vmware.com/mgrReg/plan.cfm?plan=95141&ui=www_cert

Pluralsight NSX videos

Homelab

Lots of time

Experience

This was a particularly tough exam. As I would describe myself as somewhat inexperienced in NSX compared to vSphere, I found the exam challenging. I’ve noticed that VMware have recently revised the exam reducing the number of questions down to 77 from 85, which is nice.

Posts on Virtualthoughts

Gen AI tools are making me lose my fondness for programming

ArgoCD - Ordering with ApplicationSets

KubeVirt on ARM64 - CDI Workaround

Customising ArgoCD ApplicationSets with Template Patches

Kubernetes on RK1 / Turing Pi 2: Automation with Ansible, Cilium and Cert-Manager

eBPF + Grafana Live for Metric Streaming

Thursday Tech Tidbits - Fedora Silverblue, Podman and vscode Flatpak

Replicating my vSphere network configuration in Openshift Virtualisation

Existing vSphere Design

Diving into an eBPF + Go Example: Part 1

Diving into an eBPF + Go Example: Part 3 (Bonus Round)

Diving into an eBPF + Go Example: Part 2

Changing the default apps wildcard certificate in OCP4

Improving the CI/build process for the community Rancher Exporter

Previous CI workflow

Simplify Multus deployments with Rancher and RKE2

Planning

Debugging cloud-init not executing runcmd commands

Background

What does Rancher use cloud-init for?

Installing & Using the Nvidia GPU Operator in K3s with Rancher

Step 1 - Configure Passthrough (If required)

Using the NSX-T CNI with RKE2

1. Planning

General Considerations

NSX Specific Considerations

Evaluating Harvester in vSphere

Taking a Modular Approach to my Homelab with Pulumi

Architecture

Creating Kubernetes Clusters with Rancher and Pulumi

Intro

Writing my first Prometheus exporter and scraping with Rancher

K3s, Rancher and Pulumi

Automated deployment of K3s and Rancher on vSphere with Terraform

TL;DR

Quick note on K3S with Embedded DB

End to end automation with CircleCI and ArgoCD Part 1 - Overview

End to end automation with CircleCI and ArgoCD Part 2 - CircleCI Configuration

Sign Up and Set-Up

End to end automation with CircleCI and ArgoCD Part 3 – ArgoCD

Install ArgoCD

Rancher, vSphere Network Protocol Profiles and static IP addresses for k8s nodes [Updated 2023]

K3S and Nvidia Jetson Nano

Ok, why the Nvidia Nano?

On-prem K8s clusters with Rancher, Terraform and Ubuntu

Primer

Pi-Hole and K8s v2 - Now with DNS over HTTPS

Why?

K8s, MetalLB and Pihole

MetalLB Overview

Creating a highly available, cross AZ, loadbalanced ETCD cluster in AWS with Terraform

Disclaimer

Application security with mutual TLS (mTLS) via Istio

TLS Overview

Container Packet Inspection with NSX-T

App Overview

Step by Step - Istio up and running

Removing Unused PKS LoadBalancer IP allocations in NSX-T

Introducing Velero - Backup and DR for Kubernetes Applications

What is Velero?

Bootstrapping Prometheus, Grafana and Alertmanager to PKS deployed K8s Clusters

Why Prometheus, Grafana and Alertmanager?

CKA Exam Experience (Inc study & lab guide)

Introduction

Format

Exposing the K8s dashboard via a NSX-T Load balancer

PKS, Harbor and the importance of container registries

What are container registries and why do we need them?

Introducing VMware Harbor Registry

Efficiency gains from small(er) containers

Preamble

vRealize Log Insight + PKS Integration

Introduction

My VCAP6-NV Experience

Preamble (pun intended)

NSX-T, Kubernetes and Microsegmentation

What is Microsegmentation?

Kubernetes zero to hero - from single VM webserver to a scalable microservices infrastructure

Preamble