如何高效使用Docker进行开发？Go开发镜像重建慢问题咨询

Absolutely not! Docker works great for development—you just need to tweak your setup to cut down on those frustratingly slow rebuilds and repeated package downloads. Let’s break down the most impactful fixes for your Go + Docker Compose workflow:

1. Optimize Your Dockerfile to Leverage Layer Caching #

Docker builds images in layers, and it caches each layer unless the input to that step changes. For Go projects, you can separate dependency installation from code copying to avoid re-downloading packages every time you change your code.

Here’s a revised Dockerfile that takes advantage of this:

# Use an official Go runtime as the base image
FROM golang:1.22-alpine

# Set the working directory inside the container
WORKDIR /app

# First, copy only your dependency files (go.mod + go.sum)
COPY go.mod go.sum ./
# Download dependencies—this layer will only rebuild if go.mod/go.sum changes
RUN go mod download

# Now copy the rest of your application code
COPY . .

# Build the application
RUN go build -o my-go-app .

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

With this setup, Docker will reuse the cached dependency layer every time you modify your code. You’ll only re-download packages when you actually update your dependencies in go.mod or go.sum.

2. Use Bind Mounts for Live Code Reloading #

For active development, you don’t even need to rebuild the image every time you change code. Use Docker Compose’s bind mounts to mount your local code directory directly into the container. This lets you edit code on your host machine and see changes instantly in the container.

Pair this with go run (instead of pre-building the binary) or a hot-reload tool like air for seamless iteration. Here’s an updated docker-compose.yml:

version: '3.8'
services:
  go-app:
    build: .
    # Mount your local code directory into the container's working directory
    volumes:
      - ./:/app
    # Run the app directly with go run instead of building a binary first
    command: go run main.go
    environment:
      - DB_HOST=postgres-db
      - DB_USER=dev-user
      - DB_PASSWORD=dev-pass
      - DB_NAME=dev-db
    depends_on:
      - postgres-db

  postgres-db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=dev-user
      - POSTGRES_PASSWORD=dev-pass
      - POSTGRES_DB=dev-db
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

If you want automatic reloading when code changes, replace the command with air (a popular Go hot-reload tool). You’ll need to install air in your Dockerfile first:

# Add this after setting WORKDIR
RUN go install github.com/cosmtrek/air@latest
# Then update the CMD/command in Compose to:
CMD ["air"]

3. Share Go Module Cache Between Host and Container #

If you still need to build images occasionally, you can mount your host’s Go module cache into the container to avoid re-downloading packages entirely. Add this volume to your go-app service in docker-compose.yml:

volumes:
  - ./:/app
  - $GOPATH/pkg/mod:/go/pkg/mod

This makes the container use your local machine’s already downloaded packages, drastically speeding up go mod download steps.

With these adjustments, you’ll be able to iterate on your Go code quickly—no more waiting for full image rebuilds or redundant package downloads. Docker is absolutely a fantastic tool for development, especially because it keeps your dev environment consistent with production.

内容的提问来源于stack exchange，提问作者David Alsh