How to deploy golang on Linux

In the modern software field, new development languages ​​represented by golang are becoming increasingly popular. As an increasingly popular server-side language, golang is often used to build high-performance web applications and cloud infrastructure. Linux, as one of the most ideal platforms for golang, is widely used due to its stable and secure qualities. . This article will introduce how to deploy golang on Linux and provide some useful technical details, including installing golang, setting golang environment variables, writing the first golang application, and deploying the application.

Step one: Install golang

There are many ways to install golang on Linux, such as source code installation, binary package installation, installation using the Linux package manager, etc. However, this article introduces a simpler method, namely binary package installation. Please follow the steps below.

1. First, visit the official golang download page (https://golang.org/dl/) and select the latest version of the binary package to download.

2. After the download is complete, use the tar command to extract the downloaded file to the /usr/local/ directory:

sudo tar -C /usr/local -xzf go1.15.6.linux-amd64.tar.gz

3. Next, we need to add the go binary file to the system PATH environment variable so that the go command can be accessed from anywhere. To do this, open the ~/.bashrc file and add the following lines at the end of the file:

export PATH=$PATH:/usr/local/go/bin

4. Finally, make the modified .bashrc file take effect immediately:

source ~/.bashrc

Now, you have succeeded Installed golang on Linux.

Step 2: Set golang environment variables

Setting golang environment variables is one of the necessary steps to correctly integrate golang with the operating system.

1. In the terminal, use a text editor such as vim or nano to open the ~/.bashrc file.

vim ~/.bashrc

2. Add the following content to the end of the file:

export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

3. Use the source command to update the environment variables of the current shell:

source ~/.bashrc

Note: GOPATH is the most important parameter in the Go environment. One of the important environment variables, it specifies your workspace directory that contains Go packages that can be built and installed by the go command. When setting GOPATH, you need to first create the directory manually:

mkdir $HOME/go

Step 3: Write the first golang application

After completing the installation of golang and the configuration of environment variables, next We can write our first golang application.

1. Use a text editor to create a new file named hello.go:

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

2. Save the file and use the following command in the terminal to compile it:

go build hello.go

3. After that, we can run the compiled binary directly:

./hello

When we enter this command, the output will display "Hello, World!". This indicates that golang has been successfully installed and working on Linux.

Step 4: Deploy golang application

Now that we have successfully installed golang and written and run the first application, we need to deploy the golang application to on the production server so that its functionality can be implemented in a production environment. This section will discuss how to deploy golang applications on Linux servers.

1. For go applications, we first need to upload the source code to the application directory on the server. In the application directory, you can build the application using the following command:

go build

This command will generate a binary file named main, which is the executable file of the golang application.

2. Then, we need to consider running the application as a system service. To do this, we need to write a systemd service file. In the /etc/systemd/system/ directory, use an editor such as vim or nano to create a new file with the file name myservice.service. Of course, you can also give it another name.

3. In the myservice.service file, add the following content:

[Unit]
Description=My Go Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/path/to/your/app
ExecStart=/path/to/your/app/main

[Install]
WantedBy=multi-user.target

In the above code, Description is the service description, After determines the startup time of the service, and in all systems about the network Start the service after the units are ready. ExecStart is the command that the service should use, and we should set it to the go executable file we compiled in the Linux application directory.

4. After saving the file, use the following command to start the new system service and add it to the automatic startup:

sudo systemctl start myservice
sudo systemctl enable myservice

5. After executing the above command, your service should already be in Linux It runs successfully and starts automatically on the server. You can use the following command to view the service startup status:

sudo systemctl status myservice

Summary

golang has become one of the preferred languages ​​for server-side applications, and is used in Linux application scenarios Down, it has a lot of potential. This article mainly introduces how to deploy golang applications on Linux, from the installation of golang, the configuration of environment variables to the construction of binary executable files, to the writing of systemd service files and the automatic start and stop settings of the service. I hope it can provide readers with Useful technical reference.

The above is the detailed content of How to deploy golang on Linux. For more information, please follow other related articles on the PHP Chinese website!