Thunder

Thunder: A Minimalist Backend Framework in Go

Thunder is a powerful, gRPC-Gateway-powered framework designed to facilitate scalable microservices using Prisma, Kubernetes, and Go. It enables efficient API development by providing built-in features for both gRPC and REST, ensuring high performance and rapid deployment in cloud-native environments.

Features

• gRPC + REST (gRPC-Gateway): Effortlessly expose RESTful APIs directly from gRPC services, bridging the gap between different communication protocols.
• Prisma Integration: Simplify database management with easy migrations and type-safe queries, supporting multiple databases such as PostgreSQL, MySQL, and SQLite.
• Kubernetes Ready: Seamlessly deploy and scale applications with Kubernetes, enhancing service discovery and management.
• TLS Security: Ensure secure communication for gRPC services using TLS, safeguarding data in transit.
• Structured Logging: Utilize built-in zap for streamlined logging, aiding in troubleshooting and monitoring.
• Rate Limiting & Authentication: Pre-configured middleware for managing access and usage patterns, enhancing security and efficiency.
• Modular & Extensible: Customize Thunder for specific use cases, leveraging its modular architecture to fit unique needs.
• Thunder CLI: A command-line interface that simplifies project generation and deployment processes.

Architecture Overview

Use Cases

Thunder is particularly suited for:

1. High-Performance API Development: Build gRPC-first APIs with RESTful interfaces for optimal performance and minimal latency.
2. Microservices Architecture: Facilitate efficient inter-service communication and management within Kubernetes environments.
3. Database Management: Leverage Prisma for type-safe interactions with databases, enabling smoother migrations.
4. Lightweight Backend Alternative: Offers a minimalist approach compared to traditional frameworks like Gin or Echo, without unnecessary overhead.
5. Kubernetes & Cloud-Native Applications: Perfect for containerized applications using Docker, ensuring automatic scaling and load balancing.

Getting Started

Define Your gRPC Service

Create a .proto file to define your services, like the following example:

syntax = "proto3";

package example;
import "google/api/annotations.proto";

service Example {
rpc SayHello(HelloRequest) returns (HelloResponse) {
option (google.api.http) = {
post: "/v1/example/sayhello"
body: "*"
};
};
}

message HelloRequest {
string name = 1;
}

message HelloResponse {
string message = 1;
}

Integrating with Prisma

Define your database schema in schema.prisma:

datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}

model User {
id String @default(cuid()) @id
name String
email String @unique
}

Running the Server

Launch the server to make your API accessible using:

go run ./pkg/app/server/main.go

Kubernetes Deployment

Easily deploy to Kubernetes with the necessary commands to generate TLS certificates and create secrets for your environment:

mkdir certs
openssl req -x509 -newkey rsa:4096 -keyout certs/server.key -out certs/server.crt -days 365 -nodes -subj "/CN=localhost" -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"

API Testing

Test your API endpoints effectively. Example for registering a user:

curl -k --http2 -X POST https://localhost:8080/v1/auth/register \
-H "Content-Type: application/json" \
-d '{"email":"newuser@example.com","password":"password123","name":"John","surname":"Doe","age":30}'

Contributing

Contributions are welcome. Follow the standard procedure to fork the repository, create a feature branch, and submit a pull request.

References

• Go Documentation
• gRPC-Gateway
• Prisma ORM
• Kubernetes Docs

Thunder provides a robust and streamlined solution for building microservices and high-performance APIs, tailored for modern cloud environments.