Add a New App

The Kubernetes Kit goes through the process of deploying the preconfigured apps we have defined. But you can (and should) deploy your own apps. This guide will walk you through the process of deploying a Go app from scratch.

We are going to build “machine-info” which you have used through the guided tour. We use this as an example because the code to build is minimal, but you would, in theory, have your own app you want to deploy, and you can follow this to understand the entire flow.

Prerequisites

Before starting, make sure you have a working Kubernetes cluster with the kit installed, and a domain name with DNS access. You’ll also need a Docker Hub account (or alternative container registry).

Steps

1. Configure DNS for Your App

Set up a DNS A record for your app subdomain. The host should be your app name (like machine-info) and the value should be your server’s IP address. This will make your-app-name.yourdomain.com point to your cluster.

2. Create Your Application

Create a new directory and basic Go app:

1
mkdir machine-info
2
cd machine-info

Create main.go:

1
package main
2

3
import (
4
 "fmt"
5
 "net/http"
6
 "os"
7
)
8

9
func linuxVersionHandler(w http.ResponseWriter, r *http.Request) {
10
 // Read the Linux version from /proc/version
11
 data, err := os.ReadFile("/proc/version")
12
 if err != nil {
13
  http.Error(w, "Failed to read version: "+err.Error(), http.StatusInternalServerError)
14
  return
15
 }
16
 fmt.Fprintf(w, "Linux Version: %s", string(data))
17
}
18

19
func main() {
20
 http.HandleFunc("/version", linuxVersionHandler)
21

22
 port := ":8080"
23
 fmt.Println("Server running on http://localhost" + port)
24
 if err := http.ListenAndServe(port, nil); err != nil {
25
  fmt.Println("Failed to start server:", err)
26
 }
27
}

3. Containerize Your App

Create a Dockerfile:

1
# Start with the official Golang image to build the app
2
FROM golang:1.23 AS builder
3

4
WORKDIR /app
5

6
# Copy go.mod and optionally go.sum first for caching
7
COPY go.mod ./
8
# COPY go.sum ./  # Uncomment if you have go.sum
9

10
# Copy the rest of your app
11
COPY main.go .
12

13
# Build the binary
14
RUN CGO_ENABLED=0 GOOS=linux go build -o machine-info
15

16
# Final minimal image
17
FROM alpine:latest
18

19
COPY --from=builder /app/machine-info /machine-info
20

21
EXPOSE 8080
22

23
ENTRYPOINT ["/machine-info"]

4. Build and Push Your Container Image

Initialize the Go module and build the image:

1
go mod init machine-info

Now tag and push to Docker Hub (replace YOUR-USERNAME with your actual username):

1
docker login
2
docker buildx build \
3
  --platform linux/amd64,linux/arm64 \
4
  -t YOUR_USERNAME/machine-info:latest \
5
  --push .

5. Create Kubernetes App

This will prompt you with a couple of questions and set up a development and production version of the app.

1
hungrimind kubernetes add app
2
? App name: machine-info
3
? App description: machine info
4
? Production domain (e.g., server.hungrimind.com): server.your-domain-name.com
5
? Development domain (e.g., server-dev.hungrimind.com): server-dev.your-domain-name.com
6
? Docker username: hungrimind

6. Deploy Your App

Now you should be able to see a folder based on the name you provided. The next step is to deploy it to our cluster:

1
cd machine-info
2
helm upgrade --install machine-info . --namespace machine-info --create-namespace --values ./values.yaml --debug --wait

Verification

After the deployment completes successfully, you can verify that everything is working properly.

First, check that your pods are running:

1
kubectl get pods -n machine-info

Then visit your app at https://your-app-name.yourdomain.com/version to see if it’s responding. The browser should show a secure connection, though you might see a warning if you’re using staging certificates.

If something isn’t working, check the logs to see what’s going on:

1
kubectl logs -n machine-info deployment/machine-info