Deploying and Exposing Go Apps with Kubernetes Ingress, Part 2

Lomanu4 · 10 Май 2025

In Part 1, we used Kubernetes Ingress to route traffic to two Go-based microservices based on specific paths. In this second part, we’ll explore advanced Ingress features.

Project Overview

In this part, we’ll build and deploy two updated Go-based services (API and Web) in the ~/k8s-learning/ingress/ingress-different-route directory. Unlike Part 1, where services handled specific paths (/api and /web), here both services respond to the root path (/). We’ll use Kubernetes Ingress with a rewrite rule to route /api to the API service and / to the Web service, ensuring clean URL handling.

Project Structure

We will build two services using Go:

An API service that responds to HTTP GET requests at the root path (/) with a JSON response.
A Web service that responds to HTTP GET requests at the root path (/) with an HTML response.

Then, we’ll containerize these services with Docker, set up a Kubernetes cluster using Kind, deploy the services, and configure Ingress with path rewriting to route traffic appropriately.

Tree Structure

Here’s the directory structure of the project:

k8s-learning/
└── ingress/
└── ingress-different-route/
├── api-service/
│ ├── Dockerfile
│ └── main.go
├── web-service/
│ ├── Dockerfile
│ └── main.go
└── k8s/
├── api-deployment.yaml
├── api-service.yaml
├── web-deployment.yaml
├── web-service.yaml
├── go-app-ingress.yaml
└── kind-cluster-config-with-ingress.yaml
API Service

To Initialize the Go Module for This Service, Run:

cd ~/k8s-learning/ingress/ingress-different-route/api-service
go mod init ingress-api-service-different

This command sets up the go module.

Developing the API with Go

The API service is a Go application that responds to HTTP GET requests at the root path (/) with a JSON response.

package main

import (
"encoding/json"
"fmt"
"log"
"net/http"
)

func main() {
router := http.NewServeMux()
router.HandleFunc("GET /", apiHandler)
fmt.Println("API Service started at :8080")
log.Fatal(http.ListenAndServe(":8080", router))
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
w.WriteHeader(http.StatusNotFound)
return
}
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(map[string]string{
"message": "API Service",
})
}

Changes from Part 1:

The API now uses http.NewServeMux for routing, explicitly handling GET / instead of /api.
It returns a JSON response ({"message": "API Service"}) instead of HTML.

Dockerizing the API Service

The Dockerfile remains similar to Part 1 but uses the updated image name.

# Use the official Golang image to build the app
FROM golang:1.24-alpine as builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy the Go Modules files and download dependencies
COPY go.mod ./
RUN go mod tidy

# Copy the rest of the source code into the container
COPY . .

# Build the Go app
RUN go build -o api-service .

# Start a new stage from the official Alpine image
FROM alpine:latest

# Install necessary dependencies
RUN apk --no-cache add ca-certificates

# Set the Current Working Directory inside the container
WORKDIR /root/

# Copy the pre-built binary file from the builder stage
COPY --from=builder /app/api-service .

# Expose port 8080 for the API service
EXPOSE 8080

# Command to run the executable
CMD ["./api-service"]

Build and push the image:

cd ~/k8s-learning/ingress/ingress-different-route/api-service
docker build -t olymahmudmugdho/ingress-api-service-different:latest .
docker push olymahmudmugdho/ingress-api-service-different:latest
Web Service

To Initialize the Go Module for This Service, Run:

cd ~/k8s-learning/ingress/ingress-different-route/web-service
go mod init ingress-web-service-different

I am using Go 1.24.2.

Developing the Web Service with Go

The Web service responds to HTTP GET requests at the root path (/) with an HTML response.

package main

import (
"fmt"
"net/http"
)

func webHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
w.WriteHeader(http.StatusNotFound)
return
}
fmt.Fprintf(w, "<h1>Web Service</h1>")
}

func main() {
router := http.NewServeMux()
router.HandleFunc("GET /", webHandler)
fmt.Println("Web Service started at :8080")
http.ListenAndServe(":8080", router)
}

Changes from Part 1:

The Web service now handles GET / instead of /web, using http.NewServeMux.
The response remains HTML (<h1>Web Service</h1>).

Dockerizing the Web Service

The Dockerfile is identical to Part 1’s structure but uses the updated image name.

# Use the official Golang image to build the app
FROM golang:1.24-alpine as builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy the Go Modules files and download dependencies
COPY go.mod ./
RUN go mod tidy

# Copy the rest of the source code into the container
COPY . .

# Build the Go app
RUN go build -o web-service .

# Start a new stage from the official Alpine image
FROM alpine:latest

# Install necessary dependencies
RUN apk --no-cache add ca-certificates

# Set the Current Working Directory inside the container
WORKDIR /root/

# Copy the pre-built binary file from the builder stage
COPY --from=builder /app/web-service .

# Expose port 8080 for the Web service
EXPOSE 8080

# Command to run the executable
CMD ["./web-service"]

Build and push:

cd ~/k8s-learning/ingress/ingress-different-route/web-service
docker build -t olymahmudmugdho/ingress-web-service-different:latest .
docker push olymahmudmugdho/ingress-web-service-different:latest
Setting Up Kubernetes with KIND

The Kind cluster configuration remains identical to Part 1.

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: kind-ingress

nodes:
- role: control-plane
image: kindest/node:v1.31.2
kubeadmConfigPatches:
- |
kind: InitConfiguration
nodeRegistration:
kubeletExtraArgs:
node-labels: "ingress-ready=true"
extraPortMappings:
- containerPort: 80
hostPort: 80
protocol: TCP
- containerPort: 443
hostPort: 443
protocol: TCP

- role: worker
image: kindest/node:v1.31.2

- role: worker
image: kindest/node:v1.31.2

Create the cluster:

kind create cluster --config k8s/kind-cluster-config-with-ingress.yaml

Verify:

kubectl get nodes
Installing the Ingress Controller

Deploy the NGINX Ingress controller, as in Part 1:

kubectl apply -f