Go Action Managing Go Application Lifecycles in Kubernetes

This article explores best practices for developing Go applications in Kubernetes, focusing on the different stages of a Pod’s lifecycle and the role of Kubernetes termination signals. Properly managing these phases ensures smooth application shutdowns, preventing data loss or disruptions to user experience. By mastering lifecycle management, teams can efficiently handle updates and workload adjustments.

The Three Phases of an Application’s Lifecycle

Application Startup
Application Runtime
Application Shutdown

Each phase requires careful attention to ensure everything proceeds as expected. While most teams focus solely on runtime, managing all three phases in Kubernetes is equally critical.

1. Application Startup

In Kubernetes, a Pod is considered ready when all its containers are prepared to accept requests. This readiness is determined using readiness probes and readiness gates.

The Role of Readiness Probes

A readiness probe signals whether a service is ready to handle traffic. It periodically checks the application’s state to confirm availability. Here’s an example of a readiness probe definition:

1
2
3
4
5
6
7


readinessProbe:
  httpGet:
    scheme: HTTP
    path: /ready
    port: service
  timeoutSeconds: 2
  periodSeconds: 60

Key Parameters:
• timeoutSeconds: Maximum time allowed for the probe to respond.
• periodSeconds: Frequency at which the probe is executed.

2. Application Runtime

During runtime, liveness and readiness probes monitor the service’s health. The liveness probe, in particular, detects deadlocks and determines whether a container should be restarted.

Example Liveness Probe

1
2
3
4
5
6
7
8


livenessProbe:
  httpGet:
    scheme: HTTP
    path: /health
    port: service
  timeoutSeconds: 1
  periodSeconds: 30
  initialDelaySeconds: 60

Important Considerations:
• Ensure probes respond quickly to avoid unnecessary restarts due to temporary load spikes.
• Avoid coupling probes with external service dependencies—a single failure shouldn’t trigger cascading restarts.

3. Application Shutdown

The shutdown phase involves gracefully terminating a Pod. Kubernetes manages this by sending SIGTERM followed by SIGKILL if necessary.

Graceful Shutdown in Go

Here’s an example of handling graceful shutdowns in a Go application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


func main() {
    // Step 1: Startup
    startService := time.Now()
    ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    logger := zerolog.New(os.Stdout).With().Str("service", ServiceName).Timestamp().Logger()
    
    config, err := NewConfig()
    if err != nil {
        logger.Fatal().Err(err).Msg("Unable to setup config")
    }

    mux := http.NewServeMux()
    mux.HandleFunc("/health", healthHandler(logger))
    mux.HandleFunc("/ready", readyHandler(logger))
    mux.HandleFunc("/task", taskHandler(logger))

    server := &http.Server{
        Addr:         ":" + config.ServicePort,
        Handler:      recovery(http.TimeoutHandler(mux, config.HandlerTimeout, fmt.Sprintf("server timed out, request exceeded %s\n", config.HandlerTimeout)), logger),
        ErrorLog:     log.New(logger, "", log.LstdFlags),
        ReadTimeout:  config.ReadTimeout,
        WriteTimeout: config.WriteTimeout,
    }

    waitGroup := &sync.WaitGroup{}
    
    // Run HTTP server
    waitGroup.Add(1)
    go func() {
        defer waitGroup.Done()
        errListen := server.ListenAndServe()
        if err != nil && !errors.Is(errListen, http.ErrServerClosed) {
            logger.Fatal().Err(errListen).Msg("server.ListenAndServe error")
        }
    }()

    go func() {
        <-ctx.Done()
        logger.Info().Msg("HTTP server cancelled")
        timeoutCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
        defer cancel()
        errShutdown := server.Shutdown(timeoutCtx)
        if errShutdown != nil {
            logger.Error().Err(errShutdown).Msg("server.Shutdown error")
        }
    }()

    waitGroup.Add(1)
    go performTask(ctx, waitGroup, logger)

    logger.Info().Dur("duration", time.Since(startService)).Msg("Service started successfully")
    runningService := time.Now()

    // Step 2: Runtime
    <-ctx.Done()
    stop()

    // Step 3: Shutdown
    logger.Info().Dur("duration", time.Since(runningService)).Msg("Gracefully shutting down service...")
    startGracefullyShuttingDown := time.Now()
    waitGroup.Wait()
    logger.Info().Dur("duration", time.Since(startGracefullyShuttingDown)).Msg("Shutdown service complete")
}

Key Takeaways

• Design for failure—applications must withstand underlying software or hardware failures.
• Graceful degradation and eventual consistency improve reliability and availability.
• Proper use of probes and shutdown mechanisms ensures stable and efficient management of Go applications in Kubernetes.

Developers can build resilient systems that handle disruptions seamlessly by implementing these best practices. 🚀

Long Time Link
If you find my blog helpful, please subscribe to me via RSS
Or follow me on X
If you have a Medium account, follow me there. My articles will be published there as soon as possible.