Optimizing Images for the Web with Go and Docker

mkdir ImagePipe
cd ImagePipe
go mod init github.com/JoaoOliveira889/ImagePipe

package main

import (
	"bufio"
	"fmt"
	"image"
	_ "image/jpeg" // Register JPEG decoder for image.Decode
	_ "image/png"  // Register PNG decoder for image.Decode
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/chai2010/webp" // WebP encoder library
	"golang.org/x/image/draw"  // High-performance image scaling package
)

func main() {
	var inputPath string
	var qualityStr string
	quality := 75 // Default compression quality

	// 1. Input Handling: Supports both CLI arguments and interactive mode
	if len(os.Args) >= 2 {
		inputPath = os.Args[1]
		if len(os.Args) > 2 {
			qualityStr = os.Args[2]
		}
	} else {
		// Interactive Mode for local execution
		fmt.Println("Image to WebP Optimizer")
		fmt.Println("-----------------------")
		fmt.Print("\nPath (File or Folder): ")

		scanner := bufio.NewScanner(os.Stdin)
		if scanner.Scan() {
			inputPath = scanner.Text()
		}

		fmt.Print("Quality (Default 75): ")
		if scanner.Scan() {
			qualityStr = scanner.Text()
		}
	}

	// Clean path: Remove quotes and handle escaped spaces (common when dragging files to terminal)
	inputPath = strings.Trim(strings.TrimSpace(inputPath), "\"'")
	inputPath = strings.ReplaceAll(inputPath, `\ `, " ")

	if inputPath == "" {
		fmt.Println("Error: No path provided.")
		return
	}

	// Parse quality string to integer
	if qualityStr != "" {
		if q, err := strconv.Atoi(strings.TrimSpace(qualityStr)); err == nil {
			quality = q
		}
	}

	// 2. Path Analysis: Check if target is a single file or a directory
	fileInfo, err := os.Stat(inputPath)
	if err != nil {
		fmt.Printf("Error: Path '%s' not found.\n", inputPath)
		return
	}

	if fileInfo.IsDir() {
		// Batch Processing
		fmt.Printf("\nProcessing folder: %s\n", inputPath)
		files, _ := os.ReadDir(inputPath)
		for _, f := range files {
			ext := strings.ToLower(filepath.Ext(f.Name()))
			// Filter supported image formats
			if ext == ".jpg" || ext == ".jpeg" || ext == ".png" {
				processImage(filepath.Join(inputPath, f.Name()), quality)
			}
		}
	} else {
		// Single file processing
		processImage(inputPath, quality)
	}
}

// processImage handles the decoding, resizing, and WebP encoding logic
func processImage(path string, quality int) {
	file, err := os.Open(path)
	if err != nil {
		fmt.Printf("Error opening %s: %v\n", path, err)
		return
	}
	defer file.Close()

	inInfo, _ := file.Stat()
	img, _, err := image.Decode(file) // Decode the original image buffer
	if err != nil {
		fmt.Printf("Error decoding %s: Please use JPG or PNG\n", path)
		return
	}

	// 3. Resolution Optimization: Caps width at 1600px
	bounds := img.Bounds()
	if bounds.Dx() > 1600 {
		newW := 1600
		// Calculate height maintaining the original aspect ratio
		newH := (bounds.Dy() * newW) / bounds.Dx()
		
		dst := image.NewRGBA(image.Rect(0, 0, newW, newH))
		
		// Use Catmull-Rom resampling for high-quality downscaling
		draw.CatmullRom.Scale(dst, dst.Bounds(), img, bounds, draw.Over, nil)
		img = dst
	}

	// 4. Output Creation: Append timestamp to filename to prevent overwriting
	ts := time.Now().Format("150405")
	outPath := strings.TrimSuffix(path, filepath.Ext(path)) + "_" + ts + ".webp"

	outFile, err := os.Create(outPath)
	if err != nil {
		fmt.Printf("Error creating output file: %v\n", err)
		return
	}
	defer outFile.Close()

	// 5. WebP Encoding: Apply final compression
	err = webp.Encode(outFile, img, &webp.Options{Quality: float32(quality)})
	if err != nil {
		fmt.Printf("Error encoding WebP: %v\n", err)
		return
	}

	// 6. Performance Report: Calculate and display size reduction
	outInfo, _ := os.Stat(outPath)
	savings := float64(inInfo.Size()-outInfo.Size()) / float64(inInfo.Size()) * 100
	fmt.Printf("✔ %s | Reduced: %.1f%% (Final: %d KB)\n", 
		filepath.Base(outPath), 
		savings, 
		outInfo.Size()/1024,
	)
}

"image"
	_ "image/jpeg"
	_ "image/png"

go get github.com/chai2010/webp
go get golang.org/x/image/draw
go mod tidy

go run main.go

# Stage 1: Build the binary
FROM golang:1.25.5-alpine AS builder

# Install build dependencies for CGO
RUN apk add --no-cache gcc musl-dev

WORKDIR /app

# Copy dependency files
COPY go.mod go.sum ./
RUN go mod download

# Copy the rest of the source code
COPY . .

# IMPORTANT: We use TARGETARCH to make this work on any machine
ARG TARGETARCH
RUN CGO_ENABLED=1 GOOS=linux GOARCH=$TARGETARCH go build -o imagepipe .

# Stage 2: Final lightweight image
FROM alpine:latest
RUN apk add --no-cache libc6-compat

WORKDIR /data
COPY --from=builder /app/imagepipe /usr/local/bin/imagepipe

ENTRYPOINT ["imagepipe"]

docker build -t imagepipe .

nvim ~/.zshrc

imagepipe() {
    docker run --rm -it -v "$(pwd)":/data imagepipe "$1" "$2"
}

source ~/.zshrc