A minimal Go HTTP service with health checks, built with Docker and deployed via GitHub Actions.

• HTTP Server: Simple Go HTTP server with / and /health endpoints
• Health Checks: Built-in health check endpoint for container orchestration
• Containerized: Built with Docker using Alpine Linux base image
• CI/CD: Automated build, test, and deployment pipeline
• Multi-platform: Supports Linux AMD64 and ARM64
• Security: Automated vulnerability scanning and linting

• Go 1.24+: For local development
• Docker: For container operations
• GitHub: For CI/CD pipeline

1. Open in VS Code: Clone and open the repository
2. DevContainer: VS Code will prompt to reopen in container
3. Ready: All tools pre-installed in the container

# Clone the repository
git clone git@github.com:platformfuzz/go-hello-service.git
cd go-hello-service

# Install dependencies
go mod tidy

# Run locally
go run ./cmd/server

# Test
go test ./cmd/server

# Build locally
docker build -t go-hello-service .

# Run locally
docker run -p 8080:8080 go-hello-service

# Build for multiple platforms
docker buildx build --platform linux/amd64,linux/arm64 -t go-hello-service .

• Base Image: alpine:latest
• Binary: /app/server
• Port: 8080 (configurable via PORT env var)
• Health Check: Built-in Docker health check with curl
• User: Non-root user (appuser)

The service provides a /health endpoint that returns:

{
  "status": "healthy",
  "timestamp": "2024-01-01T12:00:00Z",
  "version": "1.0.0"
}

The container includes a built-in health check:

HEALTHCHECK --interval=30s --timeout=5s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

For ECS, Kubernetes, etc., use:

{
  "healthCheck": {
    "command": [
      "CMD-SHELL",
      "curl -f http://localhost:8080/health || exit 1"
    ],
    "interval": 30,
    "timeout": 5,
    "retries": 3,
    "startPeriod": 60
  }
}

Note: Uses curl (available in Alpine base image) for HTTP health checks.

The .github/workflows/ci.yml workflow provides:

• ✅ Go Module Check: Ensures go.mod is clean
• ✅ Binary Build: Validates Go compilation
• ✅ Container Build: Tests Docker build process
• ✅ Health Check Test: Validates container health check
• ✅ Security Scan: Basic security checks
• ✅ Linting: golangci-lint integration
• ✅ Vulnerability Check: govulncheck integration
• ✅ Tests: Automated test suite

• 🚀 Build & Push: Publishes to GitHub Container Registry
• 🏷️ Tagging: Automatic latest and versioned tags
• 📦 Multi-platform: AMD64 and ARM64 images

Images are published to: ghcr.io/platformfuzz/go-hello-service:latest

• PORT: Server port (default: 8080)

See Dockerfile for build configuration:

• Multi-stage build: Go builder + Alpine runtime
• Base Image: Alpine Linux with curl
• Security: Non-root user
• Health Check: Built-in curl-based health check

Returns a hello message with hostname and timestamp.

Response:

{
  "message": "Hello, World!",
  "timestamp": "2024-01-01T12:00:00Z",
  "hostname": "container-hostname"
}

Returns service health status.

Response:

{
  "status": "healthy",
  "timestamp": "2024-01-01T12:00:00Z",
  "version": "1.0.0"
}

.
├── cmd/
│   └── server/
│       ├── main.go          # Main server implementation
│       └── main_test.go     # Unit tests
├── .github/
│   └── workflows/
│       └── ci.yml           # CI/CD pipeline
├── .devcontainer/
│   └── devcontainer.json    # VS Code DevContainer
├── .vscode/
│   ├── extensions.json      # Recommended extensions
│   └── settings.json        # Go development settings
├── Dockerfile               # Docker build configuration
├── go.mod                   # Go module definition
└── README.md               # This file

# Add a new dependency
go get github.com/example/package

# Update go.mod
go mod tidy

# Run all tests
go test ./...

# Run with coverage
go test -cover ./...

# Run specific test
go test ./cmd/server

# Build image
docker build -t go-hello-service .

# Run container
docker run -p 8080:8080 go-hello-service

# Check health
docker inspect go-hello-service --format='{{.State.Health.Status}}'

# Build multi-platform
docker buildx build --platform linux/amd64,linux/arm64 -t go-hello-service .

{
  "family": "go-hello-service",
  "containerDefinitions": [
    {
      "name": "server",
      "image": "ghcr.io/platformfuzz/go-hello-service:latest",
      "portMappings": [
        {
          "containerPort": 8080,
          "protocol": "tcp"
        }
      ],
      "healthCheck": {
        "command": [
          "CMD-SHELL",
          "curl -f http://localhost:8080/health || exit 1"
        ],
        "interval": 30,
        "timeout": 5,
        "retries": 3,
        "startPeriod": 60
      }
    }
  ]
}

version: '3.8'
services:
  server:
    image: ghcr.io/platformfuzz/go-hello-service:latest
    ports:
      - "8080:8080"
    environment:
      - PORT=8080
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8080/health || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 60s

• Vulnerability Scanning: Automated govulncheck integration
• Code Quality: golangci-lint enforcement
• Minimal Base Image: Alpine Linux for reduced attack surface
• Non-root User: Container runs as non-root user
• Graceful Shutdown: Proper signal handling
• Error Handling: Comprehensive error management

MIT License - see LICENSE file for details.

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Ensure all tests pass
5. Submit a pull request

The CI/CD pipeline will automatically validate your changes before merging.