golang daemon deployment

With the rapid development of Internet technology, various high-performance languages ​​​​are emerging in endlessly. Among them, Golang has become the language of choice for more and more developers with its efficient concurrency mechanism and concise syntax. In actual production environments, we often need to deploy our Golang applications on the server in the form of a daemon process to implement functions such as automatic startup and error restart. Next, we will introduce how to use systemd to deploy Golang applications as daemons.

1. What is a daemon process?

Simply put, a daemon process is a process that runs in the background and remains active. It does not depend on the terminal and does not terminate when the terminal is closed. It can automatically start at system startup and automatically restart when an error is encountered. It is very common in server scenarios. For example, web servers, databases, etc. all run in the form of daemon processes, ensuring system reliability and stability.

2. Why choose systemd

There are many ways to run applications as daemons in Linux systems, such as nohup, screen, etc. Although these methods are simple and easy to use, they can only meet relatively basic requirements in terms of scalability and management. systemd is a relatively new system management service, its goal is to replace services such as SysV and Upstart. Systemd takes startup time optimization as its highest guiding principle. Through analysis and testing of a large number of different Linux systems and related services, systemd has achieved a series of excellent features such as very fast startup speed and simple and easy configuration. Currently, systemd has been adopted by many Linux distributions.

3. Writing Golang applications

Assume that our application needs to monitor HTTP requests and return "hello world", first create a main.go file:

package main

import (
    "fmt"
    "net/http"
)

func HelloWorld(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World!
")
}

func main() {
    http.HandleFunc("/", HelloWorld)
    http.ListenAndServe(":8080", nil)
}

Execute the following command You can start the application:

go run main.go

You can visit http://localhost:8080 to view the effect.

4. Create a Systemd Unit file

A Systemd Unit file is a configuration file that contains performance, configuration, and start/stop information about a specific service. Before using systemd, you need to create a Unit file of the daemon startup script, named myapp.service, as shown below:

[Unit]
Description=My App
After=network.target

[Service]
User=root
WorkingDirectory=/root/myapp
ExecStart=/root/myapp/myapp
Restart=always

[Install]
WantedBy=multi-user.target

The explanation of each parameter is as follows:

• Description: Description of the service
• After: When running run level, this unit must be at the end of the sequence list. (The settings in this article indicate that the application must be started after the network service is started)
• User: The user under which the application is running
• WorkingDirectory: Application The working directory where the program runs
• ExecStart: The command executed by the application
• Restart: Automatically restart the application if the application terminates unexpectedly
• WantedBy: Used to specify which target (startup level) or multiple targets (startup level) will enable the service.

After creating the Unit file, copy it to the /etc/systemd/system/ directory.

Next, execute the following command to start the daemon process:

systemctl daemon-reload  # 重载 daemon
systemctl start myapp.service  # 启动服务
systemctl enable myapp.service  # 将服务设为开机启动

At this point, our Golang application has been deployed on the server in the form of a daemon process. You can check the service status through the following command:

systemctl status myapp.service

5. Summary

This article introduces how to use systemd to deploy Golang applications on the server in the form of a daemon. There are many ways to manage the system, and the above is just one implementation method. I hope it will inspire readers who need to run Golang applications as daemons. More details about Systemd need to be studied by yourself.

The above is the detailed content of golang daemon deployment. For more information, please follow other related articles on the PHP Chinese website!