How to use golang for packaging and deployment

With the continuous development of Internet technology, more and more companies are beginning to use golang to write back-end services. Compared with other languages, golang has great advantages in concurrent processing and performance optimization. Packaging and deployment is an important part of efficient management of golang projects. Next, this article will introduce how to use golang for packaging and deployment.

1. Use golang for packaging

Golang itself has its own packaging tools and does not need to rely on any third-party tools. To use golang for packaging, you only need to execute the following two commands:

go build -o output main.go

Among them, the -o parameter is used to specify the output executable file name, main .go is the go file to be compiled.

In addition, if you need to deploy applications on different operating systems, you can use CGO for cross-compilation. For example, if you need to deploy on windows, you can execute the following command:

CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o output.exe main.go

Among them, CGO_ENABLED It means disabling CGO because many libraries cannot use CGO on Windows; GOOS means that the target operating system is Windows; GOARCH means that the CPU architecture of the target system is AMD64.

2. Use docker for packaging

golang also has certain advantages in containerization. Using docker for packaging and deployment can separate the application from the environment it depends on, thereby ensuring the portability and consistency of the application.

First, you need to write a Dockerfile file to describe the build and deployment process of the application. The example is as follows:

FROM golang:1.12-alpine

COPY . /app

WORKDIR /app

RUN go build -o main .

EXPOSE 8080

CMD ["./main"]

Among them, FROM The statement is used to specify the base image as golang:1.12-alpine; the COPY statement is used to copy all files in the current directory to the app directory; the WORKDIR statement is used to switch to the app directory; the RUN statement is used to execute the go build command to build. ; The EXPOSE statement is used to expose the port; the CMD statement is used to start the application.

Then, execute the following command for packaging:

docker build -t myapp:latest .

Among them, the -t parameter is used to specify the image name and version number. Then Represents the current directory. After packaging is completed, you can start the container through the following command:

docker run -d -p 8080:8080 myapp:latest

Among them, the -d parameter is used to run the container in the background, and the -p parameter is used Map port 8080 in the container to port 8080 on the host.

3. Deployment using Kubernetes

Kubernetes is an open source container orchestration tool that can be used to automate the deployment, expansion and management of containerized applications. Deploying with Kubernetes improves application reliability and resiliency.

First, you need to write a deployment.yaml file to describe the deployment implementation of the application. The example is as follows:

apiVersion: apps/v1
kind: Deployment
metadata:
name: myapp
spec:
selector:

matchLabels:
  app: myapp

replicas: 3
template:

metadata:
  labels:
    app: myapp
spec:
  containers:
  - name: myapp
    image: myregistry/myapp:latest
    ports:
    - containerPort: 8080

where apiVersion represents the API version of the resource, and kind represents the resource type as Deployment ; The name field is used to specify the deployment name; the selector field is used to specify which pods are selected; the replicas field is used to specify how many pods need to be created; the template field is used to specify the template of the Pod; the containers field is used to contain one or more containers; image The field is used to specify the container image; the ports field is used to specify the port that the container listens on.

Then, execute the following command to deploy:

kubectl apply -f deployment.yaml

The -f parameter is used to specify the deployment file path. After the deployment is completed, you can view the deployment status through the following command:

kubectl get pods

Finally, you can create a service object through the following command to expose the port in the container to external users:

kubectl expose deployment myapp --type=LoadBalancer --name=myapp-service

Among them, the --type parameter is used to specify the Service type, and LoadBalancer indicates that the service is exposed externally through the cloud vendor's load balancer; The --name parameter is used to specify the Service name.

Summary

This article introduces three methods of using golang for packaging and deployment: using golang’s own packaging tool, using docker for packaging, and using Kubernetes for deployment. These methods can basically meet the needs of different scenarios. I hope they can provide some reference for you to develop and deploy golang projects.

The above is the detailed content of How to use golang for packaging and deployment. For more information, please follow other related articles on the PHP Chinese website!