How to deploy applications with Golang and Docker

In today’s software development industry, containerization technology has become an increasingly popular solution. As the most popular containerization tool currently, Docker is widely recognized for its various advantages, such as high portability, lightweight, portability, etc. At the same time, Golang, as a modern high-performance programming language, is loved by more and more developers. In this article, we will explain how to deploy applications using Golang and Docker.

Step One: Write a Golang Application

First, we need to write a Golang application. Here we take a simple web service implemented by Golang as an example. The code is as follows:

package main 

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", helloHandler) // 注册路由
    http.ListenAndServe(":8080", nil)  // 启动 HTTP 服务
}

func helloHandler(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Hello Docker and Golang!")
}

The application here will listen to port 8080 after startup and provide a simple response message on this port.

Step 2: Create a Docker image

We need to package the Golang application into a Docker image to facilitate deployment to any Docker host. Before creating a Docker image, we need to write a Dockerfile configuration file for the Golang application.

# Dockerfile
FROM golang:alpine

WORKDIR /go/src/app
COPY . .

RUN go build -o app

EXPOSE 8080
CMD ["/go/src/app/app"]

The above Dockerfile is divided into the following steps:

• Create a new image based on the Alpine image written in Golang.

• Copy the source code directory where the application is placed to the /go/src/app path of the container.

• Compile the application in the container.

• Specify the port opened by the container.

• Configure the default command for mirror startup, here is CMD ["/go/src/app/app"].

Next, build our Docker image in the local terminal and execute the following command:

$ docker build -t my-go-app:v1 .

This command will enter the current directory and create it according to the configuration file in the Dockerfile An image version v1 named my-go-app.

Step 3: Run the Docker container

After creating the Docker image, you need to start the container. We use the following command to start the my-go-app image:

$ docker run -d -p 8080:8080 my-go-app:v1

The above command is used to start the my-go-app image in a Docker container, and Map the 8080 port inside the container to the 8080 port of the host (that is, the local machine). -d means the container runs in the background, -p means port mapping. After running this command, we can access the service on the local machine. For example, by accessing http://localhost:8080 in the browser, we can see the response message of the application.

Step 4: Upload the Docker image

After we build the Docker image locally, we also need to upload it to Docker Hub or our own private warehouse , to facilitate application deployment on other Docker hosts. We need to log in to Docker Hub, that is, run the following command:

$ docker login

Next, we can upload this image by marking and pushing it. We need to execute the following command:

$ docker tag my-go-app:v1 username/my-go-app:v1
$ docker push username/my-go-app:v1

my-go-app:v1 is the image version we built locally, and username is the Docker Hub account name.

Step 5: Deploy the Docker image on the remote host

After we upload the image on Docker Hub, we can deploy ours on other machines app. First, you need to install a Docker environment on the remote host. After installing Docker, we can pull the image that has been uploaded to Docker Hub or other private warehouses on the remote machine by running the following command:

$ docker pull username/my-go-app:v1

After that, we can start the container according to the method in step three. , after starting, we can access our application on the remote host.

Summary

Through the above five steps, we successfully introduced how to deploy applications using Golang and Docker. Today, Docker has become one of the main solutions for modern application development and delivery, so by leveraging Docker to deploy our Golang applications, we can significantly reduce configuration issues and environmental issues, making our applications more portable performance and scalability.

The above is the detailed content of How to deploy applications with Golang and Docker. For more information, please follow other related articles on the PHP Chinese website!