🚀 Go Microservices with SkyWalking APM

A complete microservices architecture built with Go, PostgreSQL, KrakenD API Gateway, and Apache SkyWalking for Application Performance Monitoring (APM).

🏗️ Architecture

graph TB
    subgraph "Client Layer"
        C[Client Applications]
    end
    
    subgraph "API Gateway"
        K[KrakenD Gateway<br/>:8000]
    end
    
    subgraph "Microservices"
        U[User Service<br/>:8080]
        P[Product Service<br/>:8081]
        O[Order Service<br/>:8082]
    end
    
    subgraph "Data Layer"
        DB1[(PostgreSQL<br/>userdb)]
        DB2[(PostgreSQL<br/>productdb)]
        DB3[(PostgreSQL<br/>orderdb)]
    end
    
    subgraph "Monitoring"
        SW[SkyWalking OAP<br/>:11800/:12800]
        UI[SkyWalking UI<br/>:8088]
    end
    
    C -->|HTTP Requests| K
    K -->|Route /api/users| U
    K -->|Route /api/products| P
    K -->|Route /api/orders| O
    
    U -->|GORM| DB1
    P -->|GORM| DB2
    O -->|GORM| DB3
    
    U -.->|Traces| SW
    P -.->|Traces| SW
    O -.->|Traces| SW
    
    SW -->|Data| UI
    
    classDef serviceBox fill:#6a0dad,stroke:#fff,stroke-width:2px,color:#fff
    classDef dbBox fill:#2d5aa0,stroke:#fff,stroke-width:2px,color:#fff
    classDef monitorBox fill:#ff6b35,stroke:#fff,stroke-width:2px,color:#fff
    classDef gatewayBox fill:#28a745,stroke:#fff,stroke-width:2px,color:#fff
    
    class U,P,O serviceBox
    class DB1,DB2,DB3 dbBox
    class SW,UI monitorBox
    class K gatewayBox

Loading

✨ Features

• 🔄 Microservices Architecture: Independent services for User, Product, and Order management
• 🌐 API Gateway: Centralized routing and load balancing with KrakenD
• 📊 APM Monitoring: Complete observability with Apache SkyWalking
• 💾 Database Per Service: Dedicated PostgreSQL databases for each microservice
• 🔍 Distributed Tracing: End-to-end request tracing across services
• 🐳 Docker Compose: One-command deployment and orchestration
• 🏗️ Clean Architecture: Repository pattern with layered design
• ⚡ High Performance: Built with Go for optimal performance

🛠️ Tech Stack

Component	Technology	Purpose
Backend	Go 1.23	Microservices implementation
Database	PostgreSQL 13	Data persistence
ORM	GORM	Database abstraction
Web Framework	Gin	HTTP server and routing
API Gateway	KrakenD	Request routing and aggregation
APM	Apache SkyWalking	Performance monitoring
Containerization	Docker & Docker Compose	Service orchestration
Tracing	Go2Sky	SkyWalking Go agent

🚀 Quick Start

Prerequisites

• Docker & Docker Compose
• Go 1.23+ (for development)
• Git

1. Clone Repository

git clone <repository-url>
cd skywalking-basic

2. Environment Setup

The project includes a .env file with default configuration:

# Database Configuration
DATABASE_URL_USER=postgres://postgres:postgres@localhost:5432/userdb?sslmode=disable
DATABASE_URL_PRODUCT=postgres://postgres:postgres@localhost:5432/productdb?sslmode=disable
DATABASE_URL_ORDER=postgres://postgres:postgres@localhost:5432/orderdb?sslmode=disable

# SkyWalking Configuration
SKYWALKING_OAP=skywalking-oap:11800

3. Start All Services

# Start the entire stack
docker-compose up -d

# Check service status
docker-compose ps

4. Verify Deployment

# Test services
curl http://localhost:8080/health  # User Service
curl http://localhost:8081/health  # Product Service  
curl http://localhost:8082/health  # Order Service
curl http://localhost:8000/api/users  # Via API Gateway

📡 API Endpoints

User Service (Port 8080)

Method	Endpoint	Description
GET	/health	Health check
POST	/v1/users	Create user
GET	/v1/users	List users
GET	/v1/users/:id	Get user by ID
PUT	/v1/users/:id	Update user
DELETE	/v1/users/:id	Delete user

Product Service (Port 8081)

Method	Endpoint	Description
GET	/health	Health check
POST	/v1/products	Create product
GET	/v1/products	List products
GET	/v1/products/:id	Get product by ID
PUT	/v1/products/:id	Update product
DELETE	/v1/products/:id	Delete product

Order Service (Port 8082)

Method	Endpoint	Description
GET	/health	Health check
POST	/v1/orders	Create order
GET	/v1/orders	List orders
GET	/v1/orders/:id	Get order by ID
PUT	/v1/orders/:id	Update order
DELETE	/v1/orders/:id	Delete order

API Gateway (Port 8000)

Method	Endpoint	Description
GET	/api/users	Proxy to User Service
GET	/api/products	Proxy to Product Service
GET	/api/orders	Proxy to Order Service

📊 Monitoring & Observability

SkyWalking Dashboard

Access the SkyWalking UI at: http://localhost:8088

Features:

• Dashboard: System overview and key metrics
• Topology: Visual service dependency map
• Trace: Detailed request tracing
• Service: Individual service performance
• JVM: Runtime performance metrics

Service Discovery

graph LR
    subgraph "Service Mesh"
        direction TB
        A[API Gateway] -->|Discovers| B[User Service]
        A -->|Discovers| C[Product Service] 
        A -->|Discovers| D[Order Service]
        
        B -.->|Reports to| E[SkyWalking OAP]
        C -.->|Reports to| E
        D -.->|Reports to| E
        
        E -->|Visualizes| F[SkyWalking UI]
    end
    
    classDef serviceNode fill:#6a0dad,stroke:#fff,stroke-width:2px,color:#fff
    classDef monitorNode fill:#ff6b35,stroke:#fff,stroke-width:2px,color:#fff
    
    class A,B,C,D serviceNode
    class E,F monitorNode

Loading

🏗️ Project Structure

skywalking-basic/
├── cmd/                          # Application entry points
│   ├── userservice/main.go       # User service main
│   ├── productservice/main.go    # Product service main
│   └── orderservice/main.go      # Order service main
├── internal/                     # Private application code
│   ├── userservice/              # User service implementation
│   │   ├── config/               # Configuration
│   │   ├── handler/              # HTTP handlers
│   │   ├── model/                # Data models
│   │   ├── repository/           # Data access layer
│   │   └── service/              # Business logic
│   ├── productservice/           # Product service implementation
│   └── orderservice/             # Order service implementation
├── pkg/                          # Shared libraries
│   └── database/                 # Database utilities
├── dockerfiles/                  # Docker build files
│   ├── userservice.Dockerfile
│   ├── productservice.Dockerfile
│   └── orderservice.Dockerfile
├── gateways/                     # API Gateway configuration
│   └── krakend.json             # KrakenD configuration
├── scripts/                      # Utility scripts
│   ├── init-multiple-databases.sh
│   ├── start-services.sh
│   ├── stop-services.sh
│   └── test-services.sh
├── docker-compose.yml            # Service orchestration
├── go.mod                        # Go module dependencies
├── go.sum                        # Dependency checksums
└── .env                         # Environment variables

🔧 Development

Local Development Setup

1. Start Dependencies:

# Start only databases and monitoring
docker-compose up -d postgres skywalking-oap skywalking-ui

2. Run Services Locally:

# Terminal 1 - User Service
go run cmd/userservice/main.go

# Terminal 2 - Product Service  
go run cmd/productservice/main.go

# Terminal 3 - Order Service
go run cmd/orderservice/main.go

Testing

# Run helper scripts
./scripts/test-services.sh

# Generate test data
curl -X POST http://localhost:8080/v1/users \
  -H "Content-Type: application/json" \
  -d '{"first_name":"John","last_name":"Doe","email":"john@example.com"}'

Database Management

# Connect to user database
docker exec -it skywalking-basic_postgres_1 psql -U postgres -d userdb

# View tables
\dt

# Check data
SELECT * FROM users;

🐳 Docker Operations

Service Management

# Start all services
docker-compose up -d

# Stop all services
docker-compose down

# View logs
docker-compose logs -f userservice

# Scale services
docker-compose up -d --scale userservice=3

Health Checks

# Check all containers
docker-compose ps

# Health check script
./scripts/start-services.sh

📈 Performance Features

• Connection Pooling: Optimized database connections
• Graceful Shutdown: Clean service termination
• Error Handling: Comprehensive error management
• Rate Limiting: Built-in request throttling
• Caching: Response caching strategies
• Load Balancing: Multi-instance support

🔒 Security

• Input Validation: JSON schema validation
• SQL Injection Protection: GORM parameterized queries
• CORS Configuration: Cross-origin request handling
• Environment Variables: Secure configuration management

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Apache SkyWalking for APM capabilities
• KrakenD for API Gateway functionality
• GORM for elegant ORM support
• Gin for high-performance HTTP framework

---

⭐ Star this repository if you find it helpful!

For questions and support, please open an issue or contribute to the project.