Hello Gophers,
I’d wish to share **ebike-go**, a source-available assortment of Go providers for shared e-bike and pedal-assist bike operations:
The undertaking grew from actual operational necessities for metropolis bike-sharing applications and vacationer points of interest. From a rider’s perspective, the method is easy: scan, unlock, journey, and return. On the backend, nevertheless, each journey includes dwell machine connections, location updates, parking validation, helmet checks, pricing, promotions, funds, and operational reporting.
Any such system has turned out to be match for Go.
## The place Go matches in a shared e-bike system
### 1. Sustaining connections with numerous bikes
Every bike has an IoT controller that studies data reminiscent of:
– GPS location
– Battery stage and BMS knowledge
– Lock and using standing
– Faults and alarms
– Good helmet standing
The backend additionally must ship instructions for unlocking, locking, powering the bike, discovering a motorbike, or opening the battery compartment.
In ebike-go, the machine gateway is applied as a separate Go service. Go’s light-weight goroutines and networking help make it sensible to handle many long-lived machine connections with out requiring an advanced threading mannequin.
Gadget messages can arrive by way of TCP or MQTT. After protocol decoding, occasions are handed by way of Kafka to client and employee providers. Redis is used for ceaselessly accessed machine state, whereas enterprise occasions proceed to the order and operations providers.
The simplified move seems to be like this:
“`textual content
Bike / IoT controller
|
TCP or MQTT
|
Go machine gateway and protocol decoder
|
Kafka
|
Go customers and staff
|
Redis, MySQL, and enterprise providers
“`
This separation retains connection dealing with and binary protocol decoding away from slower enterprise operations.
### 2. Processing bursts of machine occasions
Bike visitors isn’t evenly distributed. Morning commutes, vacationer opening hours, promotions, and enormous return occasions can create sudden visitors spikes.
Go works effectively right here as a result of the providers can course of impartial messages concurrently whereas preserving the code comparatively simple. Gadget ingestion, command supply, state updates, and asynchronous duties are cut up into independently deployable providers, so the busiest half could be scaled with out scaling the whole platform.
Kafka gives buffering between dwell machine visitors and downstream processing. That is essential when bikes proceed reporting knowledge whereas a database or enterprise service is quickly sluggish.
### 3. Quick geofencing throughout unlock and return
Parking is without doubt one of the hardest operational issues in shared mobility.
Earlier than unlocking or returning a motorbike, the platform might have to find out whether or not the present location is:
– Contained in the service space
– Inside an authorised car parking zone
– Inside a no-parking or no-riding space
– Shut sufficient to a delegated station
These checks occur on the user-facing path, so latency issues. The geofencing service is written in Go and saved separate from normal enterprise APIs. This lets us optimize and scale geometry-heavy checks independently.
GPS alone isn’t all the time correct sufficient. The enterprise move can even mix geofencing with Bluetooth beacons or RFID tags to substantiate {that a} bike is parked within the right place.
### 4. Holding enterprise domains impartial
The repository is organized as a number of Go modules moderately than one massive utility. The principle service areas embody:
– API gateway and authentication
– Buyer and operator APIs
– Gadget gateway and protocol dealing with
– Gadget state customers and background staff
– Geofencing
– Order, pricing, and promotion integration
– Operational analytics
– Notifications
– Open APIs for exterior programs
Most HTTP providers use Gin. The supporting infrastructure consists of Nacos, Redis, Kafka, MySQL, Docker, and Kubernetes.
Utilizing a number of providers does add deployment and observability work, so this construction isn’t supposed as a suggestion for each Go undertaking. On this case, the boundaries observe workloads that behave in a different way: long-lived connections, CPU-heavy geofencing, user-facing APIs, and asynchronous occasion processing.
### 5. Constructing small deployment items
Go’s static binaries and comparatively quick startup are helpful for containerized deployment. Every service could be constructed, deployed, restarted, and scaled independently.
That is significantly useful for shared mobility, the place visitors varies by area and time of day. A tool gateway might have extra capability throughout a fleet rollout, whereas customer-facing APIs could peak throughout commuting hours.
## Enterprise capabilities constructed on prime
The Go providers help greater than bike connectivity. The platform additionally covers:
– The entire scan, unlock, journey, and return course of
– GPS geofences, Bluetooth parking beacons, and RFID parking factors
– Good helmet pairing, standing checks, and return guidelines
– Configurable fares for various areas and automobile sorts
– Trip passes, coupons, memberships, referrals, and promotional campaigns
– Multi-tenant operations
– Service provider accounts, revenue-sharing information, refunds, and income studies
The purpose is to offer a sensible basis for organizations working their very own shared e-bike service, whereas preserving machine communication and operational guidelines underneath their management.
## What I’d like suggestions on
I’m particularly all in favour of listening to from Go builders who’ve labored on IoT, mobility, or real-time programs:
– How do you construction connection possession and command supply throughout a number of gateway cases?
– Which approaches have labored effectively for high-frequency geospatial checks in Go?
– The place would you draw service boundaries in a system that mixes IoT visitors and transactional enterprise flows?
– Which components of this undertaking could be most helpful to doc or present as standalone examples?
Points and pull requests are welcome, particularly for bug fixes, documentation, observability, and clear instance configurations.
Repository: **GitHub – wanghengwen/ebike-go: 共享电单车系统的开源实现，包括设备接入/业务处理/结算分账等，适合城市运营以及景区场景 · GitHub**
