Click the “blue text” above to follow us
Late at night, the production environment needs code updates, but we cannot affect user experience? Every backend developer has likely faced this situation. I remember when I first encountered this problem, the whole team was confused. Restart the service? Users would be furious. Not updating? Bugs won’t be fixed. This dilemma has a particularly elegant solution in Go—smooth upgrades.
Go.
Signal Handling: A Lifesaver for Go Programmers
Imagine your server is handling thousands of requests, and then your boss says: “Quickly deploy the new version to fix that payment bug!” The traditional approach is to kill the process and start the new version, but the consequences—many users fail to make payments, and the customer service line gets flooded.
In Go, we can utilize the signal handling mechanism to achieve smooth upgrades. Simply put, it allows the running program to capture specific system signals (like SIGUSR2) and gracefully switch traffic to the new process while ensuring that existing connections are properly handled. Brilliant! It’s like a traffic cop directing traffic, not shutting down the road but gradually guiding vehicles to detour.
func main() {
server := &http.Server{Addr: ":8080", Handler: myHandler()}
go server.ListenAndServe()
// Capture SIGUSR2 signal
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGUSR2)
<-sig // Wait for signal
// Gracefully shut down upon receiving signal
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
server.Shutdown(ctx)
}
This code may seem simple, but it hides some intricacies. We create a signal channel specifically waiting for the arrival of the SIGUSR2 signal. Once the signal is received, the server initiates the graceful shutdown process—it stops accepting new requests but ensures that already received requests are completed. See, how considerate! But wait, this only solves the “shutdown” problem; how do we start the new service?
1.
Zero Downtime Deployment: The Perfect Combination of Technology and Art
Zero downtime deployment sounds impressive, but the principle is not complicated. The key point is: the parent process forks a child process, and the child process inherits the listening socket of the parent process. This way, the new version (child process) can seamlessly take over the traffic from the old version (parent process). To use a restaurant analogy: it’s not about closing the restaurant for renovations and reopening; it’s about quietly changing the chef and menu without affecting the diners.
In Go, we typically use libraries like fvbock/endless to implement this, which encapsulates complex low-level operations, allowing us to focus on business logic. Although the standard library does not directly provide this functionality, it is not complicated to implement; the core is to utilize the exec series of functions in the syscall package. So, the next time someone says Go is not suitable for high-availability services, you can throw this code in their face:
import "github.com/fvbock/endless"
func main() {
// Use endless instead of the standard http package
endless.ListenAndServe(":8080", myHandler())
// When receiving the SIGUSR2 signal, it will automatically perform a smooth restart
}
2.
Practical Details: The Devil is in the Details
Signals and process switching sound simple, but there are several key details that must be noted during practical implementation:
First, during the smooth upgrade process, the connection exhaustion strategy is crucial. You cannot wait indefinitely for all connections to end, as some long connections may remain active. Setting a reasonable timeout (like 30 seconds) is a good practice. Secondly, do not forget to handle the file descriptor inheritance issue. In Linux systems, after