Prerequisites

Ensure you have the following installed and configured in your production environment:

• Docker
• Go (Go modules enabled)
• Access to your production environment for deployment

Step 1: Clone the Repository

Clone the github.com/docker/go-metrics repository. This contains the source code and necessary dependencies.

git clone https://github.com/docker/go-metrics.git
cd go-metrics

Step 2: Build the Go Application

To build the application, navigate to the project directory and execute the go build command. The project uses Go modules, so ensure to omit the vendor flag.

go build -o go-metrics

This will produce an executable named go-metrics in your current directory.

Step 3: Create a Dockerfile

Create a Dockerfile in the root of the project directory to define the container image. Below is an example Dockerfile to build the Go application in a production-ready manner.

# Start with the official Golang base image
FROM golang:1.20 AS builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy the above files into the container
COPY . .

# Build the Go application
RUN go build -o go-metrics .

# Start with a minimal base image for the final execution
FROM alpine:latest

# Set the Current Working Directory
WORKDIR /root/

# Copy the Pre-built binary file from the previous stage
COPY --from=builder /app/go-metrics .

# Command to run the executable
CMD ["./go-metrics"]

Step 4: Build the Docker Image

Build the Docker image using the Dockerfile created in the previous step. Run the command below in the root of your project.

docker build -t go-metrics:latest .

Step 5: Run the Docker Container

Deploy the application by running the created Docker image within a container. You may need to specify environment variables or volume mounts based on your application requirements.

docker run -d \
  --name go-metrics \
  -p 8080:8080 \
  go-metrics:latest

Step 6: Configure Monitoring and Logging

In a production environment, configure monitoring and logging for the application to keep track of its performance and health. Implement logging strategies within the Go application using libraries such as “logrus” or the built-in log package.

Here’s a small snippet demonstrating basic logging:

package main

import (
    "log"
    "os"
)

func main() {
    logger := log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)

    logger.Println("Starting go-metrics application")
}

Step 7: Test the Deployment

After deploying, test the application by accessing it via the IP address of your production server. Use tools like curl or web browsers to ensure that the application responds as expected.

curl http://<YOUR_PRODUCTION_IP>:8080

Step 8: Ongoing Maintenance and Updates

For ongoing maintenance, ensure to update your Docker image regularly to incorporate any patches or improvements. Follow container best practices by scanning for vulnerabilities and keeping dependencies up-to-date.

To update, pull the latest changes, rebuild the image, and redeploy:

git pull origin main
docker build -t go-metrics:latest .
docker run -d --rm \
  --name go-metrics \
  -p 8080:8080 \
  go-metrics:latest

Source

Information used in this documentation is based on the code and structure provided in the github.com/docker/go-metrics repository.