techschool/simplebank
Simplebank
Simplebank is a financial services backend application built with Go that manages bank accounts and transfers. It utilizes a dual-protocol interface, providing both gRPC and REST APIs via Protocol Buffers to support different client communication requirements.
The system implements a PostgreSQL data layer with versioned schema migrations and type-safe query generation. It handles financial operations through atomic fund transfers and balance change tracking to maintain consistent audit trails.
The architecture includes an asynchronous task worker system using a message queue to offload long-running processes and middleware for token-based user authentication and role-based request authorization. The project also employs interface-based mock injection for unit testing and is packaged for deployment on Kubernetes clusters using containerization.
Features
- Bank Account Management - Provides a financial services backend for managing bank accounts and fund transfers.
- Banking Backends - Provides a complete financial services backend for managing bank accounts and funds transfers.
- Inter-Account Fund Transfers - Executes the movement of funds between bank accounts using atomic transactions.
- Balance Tracking - Maintains a complete audit trail by recording every fund addition or subtraction as a distinct entry.
- PostgreSQL Database Clients - Implements a persistent data layer with connection management and SQL generation for PostgreSQL.
- Atomic Transactions - Wraps multiple balance updates in atomic transactions to ensure financial consistency and prevent partial updates.
- Financial Transaction Processing - Implements a system for recording and managing financial payments and account balances.
- Multi-Protocol Routing - Routes both gRPC and RESTful HTTP requests through a single unified gateway interface.
- API Gateway - Implements a gateway that maps web requests to both gRPC and HTTP backend service protocols.
- REST-to-gRPC Gateways - Supports diverse client needs by serving functionality through both gRPC and RESTful HTTP interfaces.
- Authorization Middleware - Intercepts API calls using middleware to verify security tokens and enforce role-based access controls.
- Request-Level Role Authorization - Enforces role-based permissions on each API request to block unauthorized actions.
- Password Hashing Utilities - Uses specialized hashing algorithms to securely transform passwords into irreversible hashes.
- User Authentication Systems - Implements frameworks for verifying user identity and controlling access to sensitive financial resources.
- Schema Migration Scripts - Tracks and applies incremental database changes through ordered scripts to synchronize data structures.
- Database Schema Migrations - Automates the application of versioned updates to database schemas using migration scripts.
- Type-Safe Database Clients - Generates strongly-typed Go interfaces for database operations to ensure compile-time safety.
- API Code Generators - Produces server stubs and client libraries from Protocol Buffer interface definitions.
- Asynchronous Task Processing - Offloads long-running jobs to background workers via a message queue to maintain responsiveness.
- Application Containerization - Packages binaries and configurations into portable container images for consistent deployment.
- Kubernetes Application Deployments - Orchestrates the deployment of containerized services and their dependencies on Kubernetes clusters.
- Kubernetes Application Deployments - Orchestrates the deployment of containerized services to Kubernetes clusters with ingress routing.
- Message Queue Workers - Offloads time-consuming background tasks to a separate worker system using a message queue.
- gRPC Code Generators - Automatically generates typed Go code for gRPC clients and servers from .proto files.
- Go Code Generators - Translates database schemas and raw queries into type-safe Go code to eliminate manual boilerplate.
- Dual Protocol APIs - Provides an API that is accessible via both gRPC and REST protocols for flexible client integration.
- Asynchronous Task Queues - Executes long-running processes in the background via a task queue to keep the request loop non-blocking.
- Interface-Based Test Doubles - Utilizes Go interfaces to inject mock objects for isolated unit testing of business logic.
