12.3 Deployment

When our web application is finally production ready, what are the steps necessary to get it deployed? In Go, an executable file encapsulating our application is created after we compile our programs. Programs written in C can run perfectly as background daemon processes, however Go does not yet have native support for daemons. The good news is that we can use third party tools to help us manage the deployment of our Go applications, examples of which are Supervisord, upstart and daemontools, among others. This section will introduce you to some basics of the Supervisord process control system.

Daemons

Currently, Go programs cannot cannot be run as daemon processes (for additional information, see the open issue on github here). It's difficult to fork existing threads in Go because there is no way of ensuring a consistent state in all threads that have been used.

We can, however, see many attempts at implementing daemons online, such as in the two following ways;

MarGo one implementation of the concept of using Command to deploy applications. If you really want to daemonize your applications, it is recommended to use code similar to the following:

	d := flag.Bool("d", false, "Whether or not to launch in the background(like a daemon)")
	if *d {
		cmd := exec.Command(os.Args[0],
			"-close-fds",
			"-addr", *addr,
			"-call", *call,
		)
		serr, err := cmd.StderrPipe()
		if err != nil {
			log.Fatalln(err)
		}
		err = cmd.Start()
		if err != nil {
			log.Fatalln(err)
		}
		s, err := ioutil.ReadAll(serr)
		s = bytes.TrimSpace(s)
		if bytes.HasPrefix(s, []byte("addr: ")) {
			fmt.Println(string(s))
			cmd.Process.Release()
		} else {
			log.Printf("unexpected response from MarGo: `%s` error: `%v`\n", s, err)
			cmd.Process.Kill()
		}
	}

Another solution is to use syscall, but this solution is not perfect:

	package main
	 
	import (
		"log"
		"os"
		"syscall"
	)
	 
	func daemon(nochdir, noclose int) int {
		var ret, ret2 uintptr
		var err uintptr
	 
		darwin := syscall.OS == "darwin"
	 
		// already a daemon
		if syscall.Getppid() == 1 {
			return 0
		}
	 
		// fork off the parent process
		ret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)
		if err != 0 {
			return -1
		}
	 
		// failure
		if ret2 < 0 {
			os.Exit(-1)
		}
	 
		// handle exception for darwin
		if darwin && ret2 == 1 {
			ret = 0
		}
	 
		// if we got a good PID, then we call exit the parent process.
		if ret > 0 {
			os.Exit(0)
		}
	 
		/* Change the file mode mask */
		_ = syscall.Umask(0)
	 
		// create a new SID for the child process
		s_ret, s_errno := syscall.Setsid()
		if s_errno != 0 {
			log.Printf("Error: syscall.Setsid errno: %d", s_errno)
		}
		if s_ret < 0 {
			return -1
		}
	 
		if nochdir == 0 {
			os.Chdir("/")
		}
	 
		if noclose == 0 {
			f, e := os.OpenFile("/dev/null", os.O_RDWR, 0)
			if e == nil {
				fd := f.Fd()
				syscall.Dup2(fd, os.Stdin.Fd())
				syscall.Dup2(fd, os.Stdout.Fd())
				syscall.Dup2(fd, os.Stderr.Fd())
			}
		}
	 
		return 0
	}

While the two solutions above implement daemonization in Go, I still cannot recommend that you use either methods since there is no official support for daemons in Go. Notwithstanding this fact, the first option is the more feasible one, and is currently being used by some well-known open source projects like skynet for implementing daemons.

Supervisord

Go has been described above, there are two options currently are to realize his daemon, but the government itself does not support this one, so it is recommended that you use sophisticated tools to manage our third-party applications, here I'll give you a present more extensive use of process management software: Supervisord. Supervisord is implemented in Python a very useful process management tool. supervisord will help you to manage applications into daemon process, but can be easily turned on via the command, shut down, restart, etc, and it is managed by the collapse will automatically restart once the process so that you can ensure that the program execution is interrupted in the case there are self-healing capabilities.

I stepped in front of a pit in the application, because all applications are made Supervisord parent born, then when you change the operating system file descriptor after, do not forget to restart Supervisord, light restart following application program useless. I just had the system installed after the first installed Supervisord, then start the deployment process, modify the file descriptor, restart the program, that the file descriptor is already 100,000, but in fact Supervisord this time or the default 1024, led him to manage the process All descriptors is 1024. pressure after opening up the system to start a newspaper run out of file descriptors, search for a long time to find the pit.

Supervisord installation

Supervisord can sudo easy_install supervisor installation, of course, can also Supervisord official website to download, unzip and go to the folder where the source code, run setup.py install to install.

Must be installed using easy_install setuptools

Open the http://pypi.python.org/pypi/setuptools# files, depending on your system version of python download the appropriate file, and then execute sh setuptoolsxxxx.egg, so that you can use easy_install command to install Supervisord.

Supervisord Configure

Supervisord default configuration file path is /etc/supervisord.conf, through a text editor to modify this file, the following is a sample configuration file:

;/etc/supervisord.conf
[unix_http_server]
file = /var/run/supervisord.sock
chmod = 0777
chown= root:root

[inet_http_server]
# Web management interface settings
port=9001
username = admin
password = yourpassword

[supervisorctl]
; Must 'unix_http_server' match the settings inside
serverurl = unix:///var/run/supervisord.sock

[supervisord]
logfile=/var/log/supervisord/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB       ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10          ; (num of main logfile rotation backups;default 10)
loglevel=info               ; (log level;default info; others: debug,warn,trace)
pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=true              ; (start in foreground if true;default false)
minfds=1024                 ; (min. avail startup file descriptors;default 1024)
minprocs=200                ; (min. avail process descriptors;default 200)
user=root                 ; (default is current user, required if root)
childlogdir=/var/log/supervisord/            ; ('AUTO' child log dir, default $TEMP)

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
; Manage the configuration of a single process, you can add multiple program
[program: blogdemon]
command =/data/blog/blogdemon
autostart = true
startsecs = 5
user = root
redirect_stderr = true
stdout_logfile =/var/log/supervisord/blogdemon.log

Supervisord management

After installation is complete, there are two Supervisord available command line supervisor and supervisorctl, command explained as follows:

Supervisord, initial startup Supervisord, start, set in the configuration management process.
Supervisorctl stop programxxx, stop one process(programxxx), programxxx for the [program: blogdemon] in configured value, this example is blogdemon.
Supervisorctl start programxxx, start a process
Supervisorctl restart programxxx, restarting a process
Supervisorctl stop all, stop all processes, Note: start, restart, stop will not load the latest configuration files.
Supervisorctl reload, load the latest configuration file, and press the new configuration to start, manage all processes.

Summary

This section we describe how to implement daemon of the Go, but due to the current lack of Go-daemon implementation, need to rely on third-party tools to achieve the application daemon management approach, so here describes a process using python to write management tools Supervisord by Supervisord can easily put our Go up and application management.

8.3 KiB Raw Blame History