Skip to content
← Notebook
Design· 4 min read· From production

From jump-server deploys to Kubernetes: migrating a product to AKS

How I moved a five-part product from day-long manual releases to automated deployments on AKS in about 30 minutes, with a self-hosted registry, Jenkins, AGIC and Istio mTLS.

Before: components were deployed by hand from a jump server, taking about a day. After: Jenkins builds Docker images, pushes them to a self-hosted registry, and deploys to AKS, where AGIC handles ingress and Istio secures pod-to-pod traffic with mTLS.Before: manual deploysjump server → prod · ~1 dayAFTER: ~30 MIN, AUTOMATEDApp codeUI + 4 svcsJenkinsbuilds imagesPrivate registryself-hostedAKS CLUSTERAGIC ingressApp Gateway → servicesUI app+ sidecar4 services+ sidecarsIstio mTLSkeys rotated every 24h

At Digitate I initiated, and then led, the move of our product from manual deployments to Kubernetes on Azure (AKS). Releases went from a day-long manual job to an automated rollout of about 30 minutes, and the work earned me a Special Achievement Award. This post covers where we started, the constraints that shaped the design, and what I’d do differently today.

Where we started

The product had five parts: one UI app and four microservices, using Netflix Eureka for service discovery.

We released roughly every three weeks, and each release took about a full day. Deploying meant logging in to a jump server and rolling out each component to production by hand. That brought the usual problems:

  • A day of someone’s time for every release, so releases stayed infrequent.
  • Every step done by hand on production, which made each release risky.

The constraints

  • No Docker Hub and no Azure Container Registry (ACR). Neither public nor managed registries were allowed, so images had to live somewhere we hosted ourselves.
  • Traffic between services had to be secure. Splitting the product into containers means more network traffic between them, and all of it needed protecting.
  • New technology for the team, me included. Nobody had run this stack in production before, so I learned it from the documentation as I went.

Step 1: Containerise every component

I packaged the UI and each of the four services as Docker images, so the same artefact runs identically in every environment. On its own, that removes most environment drift.

Step 2: Build a private registry and automate with Jenkins

With Docker Hub and ACR both ruled out, I set up a private container registry myself and integrated it with Jenkins. Each build produces an image, pushes it to the registry, and kicks off the deployment. This pipeline replaced the jump server.

Step 3: Run it on AKS behind AGIC

The workloads run on Azure Kubernetes Service (AKS), as Deployments managing Pods. Kubernetes keeps the desired number of replicas running, replaces crashed pods, and rolls out new versions gradually. External traffic comes in through the Application Gateway Ingress Controller (AGIC), which lets Azure Application Gateway route requests to services in the cluster.

Step 4: Secure pod-to-pod traffic with Istio

I added the Istio service mesh so services talk to each other over mutual TLS. Istio rotates the keys and certificates automatically every 24 hours, so traffic between pods stays encrypted and authenticated, and no service has to manage its own certificates.

Key decisions

DecisionChoseTrade-off
Image storageSelf-hosted private registry, wired into JenkinsOne more system to run and maintain vs. meeting the "no Docker Hub, no ACR" rule
PlatformAKS with AGIC for ingressTied to Azure vs. a managed control plane and a managed gateway in front of the cluster
Service-to-service securityIstio mTLS, keys rotated every 24hSidecar overhead and a learning curve vs. no service handling its own certificates
DeliveryJenkins pipeline instead of manual jump-server deploysUp-front effort to automate vs. 30-minute, repeatable releases

What went wrong

A lot, at first. The first deployment broke in many places. The stack was new to everyone, me included, so I worked through each failure one at a time, mostly with the official documentation open. Each fix taught me something about how Kubernetes, the networking and the mesh actually behave, which no tutorial had. By the end I understood the platform far better than if everything had worked first time.

The result

Before After
How we deployed By hand, via a jump server Automated Jenkins → registry → AKS pipeline
Time per deployment About 1 day About 30 minutes, after all checks pass
Pod-to-pod security (no service mesh) Istio mTLS, keys rotated every 24h

What I’d do differently

I’d use Helm and Terraform from day one:

  • Helm to template the Kubernetes manifests, so each environment is just different values rather than a copy of the same YAML.
  • Terraform to define the AKS cluster, Application Gateway and networking as code, so the whole platform can be reviewed, reproduced and rebuilt.

Takeaways

  • Constraints shape the architecture. “No Docker Hub, no ACR” is why a self-hosted registry exists in this design. Write constraints down first.
  • Containerise first. It pays off on its own and makes the Kubernetes step smaller.
  • Automation is the real win. Kubernetes made deployments repeatable, but the Jenkins pipeline is what turned a day of manual work into 30 minutes.
  • You don’t need to know it all before starting. Reading the docs and fixing things as they break is a valid way to learn a platform.
#kubernetes#aks#docker#istio#jenkins#devops#migration