Effortlessly Deploy to Azure Kubernetes with Open Source Tools Draft and Acorn
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 🚀
Pre-requisites
Before you begin, make sure you have access to an Azure Subscription. You will also need to have the following tools installed on your machine.
If you already have these tools installed, feel free to jump to Step 1.
I ran the commands below from a terminal on macOS. If you are on a Linux or Windows machine, please refer to each tool’s documentation page (linked above) for OS-specific installation instructions.
# Install Azure CLI
brew update && brew install azure-cli
# Install Git CLI
brew install git
# Install Draft CLI
brew tap azure/draft
brew install draft
# Install Acorn CLI
brew install acorn-io/cli/acorn
Step 1: Create an AKS cluster and install Acorn
Creating an AKS cluster can take a few minutes, so let’s get the process started.
# Make sure you are logged into Azure
az login
# Make sure you are working with the proper Azure subscription
az account --set <YOUR_SUBSCRIPTION_NAME>
# Change this to your preferred Azure region
location=westus3
# To avoid any naming conflicts, store a random number which will be used in deployments
rand=$RANDOM
# Create a resource group
az group create --name rg-demoapp$rand \
--location $location
# Create an AKS cluster
az aks create --name aks-demoapp$rand \
--resource-group rg-demoapp$rand \
--enable-addons web_application_routing # <-- this installs a managed nginx ingress controller
For this demo, the only requirement is the Kubernetes cluster must have an ingress controller for Acorn to expose web applications with publicly accessible endpoints. Rather than installing an ingress controller manually, we’ll leverage the Web Application Routing add-on for AKS.
AKS clusters are highly configurable, so I recommend you explore the documentation linked above or visit some of the OSS Labs repo that I’ve been contributing to.
With the AKS cluster deployed, you’ll need to grab the credentials so we can connect to the cluster using kubectl and install Acorn into it.
If you don’t have
kubectlinstalled, run the following command to install it.
az aks install-cli
Pull down the kubectl credentials with the following command.
az aks get-credentials --name aks-demoapp$rand \
--resource-group rg-demoapp$rand
Verify you have access to the cluster.
kubectl cluster-info
Installing Acorn on the cluster.
acorn install
If you are interested in learning about what gets installed with the command above, visit the Acorn docs to learn more. If you are familiar with Kubernetes and want to see all the objects that gets created in your cluster, you can run the following command to output the manifest files.
acorn install -o yaml
Step 2: Package your Acorn app
We need an app to deploy, so clone a version of the Azure Voting App, which I’ve re-written using Rust (I’m learning Rust so be kind 😅).
git clone --branch postgres https://github.com/pauldotyu/azure-voting-app-rust.git
cd azure-voting-app-rust
Acorn will take care of creating your Kubernetes manifest files but it expects that you have a Dockerfile ready to containerize your app. Instead of writing a Dockerfile from scratch, we’ll use the Draft CLI to generate one for us. Draft is able to detect languages used within your project and generate the appropriate Docker manifest to containerize your app.
Make sure you are in the
azure-voting-app-rustdirectory before running thedraftcommand.
draft create --dockerfile-only
You will be prompted to enter the port to expose in the container. Enter 8080 as the port.
[Draft] --- Dockerfile Creation ---
✔ Please Enter the port exposed in the application: 8080
Draft may not always produce a perfect Dockerfile and may require tweaking. However, it does provide a solid starting point. As an example, if you inspect the newly created Dockerfile, you’ll notice it’s using an older version of Rust (1.58.0). Let’s update the first line of the Dockerfile to use the latest version; which at the time of this writing is 1.64.0.
sed -i -e 's/rust:1.58.0/rust:1.64.0/' Dockerfile
Now here’s the “gotcha”… you don’t need to write Kubernetes manifest files to deploy your app. Instead, you will need to create another type of manifest file named Acornfile. This file is written in JSON-like syntax, feels very similar to a Docker Compose or Helm, and is used to package your application as an Acorn app.
Let’s create an Acornfile that describes how our application should be deployed to Kubernetes. The Acornfile will deploy two containers with environment variables for each; one database container with the password set in plain text, and one web app container with a connection string to the database. It will also expose the web application over HTTP using the Kubnernetes ingress controller that has been deployed in your cluster.
The password is in plain text for demo purposes but you should take a look at Acorn’s secrets management system.
cat << EOF > Acornfile
containers: db: {
image: "postgres:15.0-alpine"
env: {
"POSTGRES_PASSWORD": "mypassword"
}
ports: "5432/tcp"
}
containers: web: {
build: "."
env: {
"DATABASE_URL": "postgres://postgres:mypassword@db"
}
ports: publish: "8080/http"
dependsOn: ["db"]
}
EOF
The full reference for
Acornfileschema can be found here
Step 3: Deploy the Acorn app to AKS
Now, you could run the acorn run command and have Acorn build your container and deploy to AKS at the same time. Instead, we’ll publish the Acorn app artifacts to Azure Container Registry (ACR) and deploy it from there.
If you do not have an ACR resource yet, create one using the following command.
az acr create --name acrdemoapp$rand \
--resource-group rg-demoapp$rand \
--sku Standard \
--admin-enabled
Log into the container registry by grabbing the admin credentials and passing it into the acorn login command.
az acr credential show --name acrdemoapp$rand --query "passwords[0].value" -o tsv | acorn login acrdemoapp$rand.azurecr.io -u acrdemoapp$rand --password-stdin
Build the Acorn artifact.
acorn build -t acrdemoapp$rand.azurecr.io/azure-vote:v0.1 .
Push the Acorn artifact to ACR.
acorn push acrdemoapp$rand.azurecr.io/azure-vote:v0.1
Deploy the Acorn app to AKS and wait for the endpoints to become healthy.
acorn run --name azure-vote-$rand acrdemoapp$rand.azurecr.io/azure-vote:v0.1
You can also run the following command to view the status of the app. Once the app is fully deployed you will be able to navigate to the endpoint URL listed. Below is an example of what the output should look like.
$ acorn apps
NAME IMAGE HEALTHY UP-TO-DATE CREATED ENDPOINTS MESSAGE
azure-vote-10981 acrdemoapp10981.azurecr.io/azure-vote:v0.1 2 2 78s ago http://web-azure-vote-10981-d70891c5f27d.v9lov9.alpha.on-acorn.io => web:8080 OK
Finally, you can browse to the endpoint URL and submit your vote!
Summary
Overall, I think the Draft and Acorn projects are awesome tools to get developers up and running as quick as possible on Kubernetes.
One of the initial hurdles developers face when considering Kubernetes as a hosting platform is knowing how to package their applications into containers. Learning how to author a Dockerfile can be a challenge but with Draft CLI, you can automate most of this. Draft does more than just create Docker manifests… it can also create Kubernetes manifests, Helm charts, GitHub automation workflows, and publish your containers to Azure Container Registry. There is also an extension for Visual Studio Code that will provide a graphical user interface for some of the draft CLI commands.
When it comes to Kubernetes, the Acorn packaging framework aims to abstract much of Kubernetes away from you. Granted you will need to become familiar with the Acornfile schema and acorn CLI commands but it may be a more approachable way to onboarding and operating your apps on any Kubernetes cluster.
Lastly, with the AKS Web Application Routing add-on, even ingress controller installation and management can be abstracted away from you as Azure will take care of this.
I’d love to hear how this approach to onboarding to Kubernetes and/or AKS works for you. If you have any feedback or questions, feel free to let me know in the comments below or on social channels (Twitter, Mastodon, or Linkedin). Cheers!
Clean up
When you’re done testing, you should tear down the deployment using the following commands.
# Stop and remove the Acorn app deployment
acorn rm $(acorn apps -qa)
# Delete the Azure resources
az group delete --name rg-demoapp$rand -y --no-wait