Self-Hosted Geofencing & Spatial Query Engines: Tile38 vs PostGIS vs Redis Geospatial

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# docker-compose.yml for Tile38
version: '3'
services:
  tile38:
    image: tile38/tile38:latest
    ports:
      - "9851:9851"
    volumes:
      - tile38_data:/data
    command: tile38-server /data

volumes:
  tile38_data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Set moving objects with real-time updates
tile38-cli
> SET fleet driver:1 POINT 40.7484 -73.9857
> SET fleet driver:2 POINT 40.7589 -73.9851
> SET fleet driver:3 POINT 40.7128 -74.0060

# Create a geofence around Times Square (500m radius)
> SETHOOK delivery-zone http://webhook.example.com/delivery NEARBY fleet FENCE POINT 40.7580 -73.9855 500

# Webhook fires when driver:1 enters the zone
# POST http://webhook.example.com/delivery
# {"hook":"delivery-zone","id":"driver:1","detect":"inside","key":"fleet",...}

# Find all drivers within 3km of a location
> NEARBY fleet POINT 40.7580 -73.9855 3000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# docker-compose.yml for PostGIS
version: '3'
services:
  postgis:
    image: postgis/postgis:15-3.4
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: geospatial
      POSTGRES_USER: geo
      POSTGRES_PASSWORD: changeme
    volumes:
      - pg_data:/var/lib/postgresql/data
    command: >
      -c shared_buffers=1GB
      -c effective_cache_size=3GB
      -c maintenance_work_mem=256MB
      -c wal_buffers=16MB

volumes:
  pg_data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

-- Enable PostGIS
CREATE EXTENSION postgis;
CREATE EXTENSION postgis_topology;

-- Create a spatial table for store locations
CREATE TABLE stores (
    id SERIAL PRIMARY KEY,
    name TEXT,
    location GEOGRAPHY(POINT, 4326)
);

-- Create spatial index
CREATE INDEX stores_location_idx ON stores USING GIST (location);

-- Insert store locations
INSERT INTO stores (name, location) VALUES
    ('Downtown Store', ST_SetSRID(ST_MakePoint(-73.9857, 40.7484), 4326)),
    ('Midtown Store', ST_SetSRID(ST_MakePoint(-73.9851, 40.7589), 4326)),
    ('Upper East Store', ST_SetSRID(ST_MakePoint(-73.9554, 40.7749), 4326));

-- Find all stores within 2km of a user location
SELECT name, ST_Distance(location, 
    ST_SetSRID(ST_MakePoint(-73.9855, 40.7580), 4326)
) AS distance_meters
FROM stores
WHERE ST_DWithin(location,
    ST_SetSRID(ST_MakePoint(-73.9855, 40.7580), 4326),
    2000
)
ORDER BY distance_meters;

-- Create a custom geofence polygon
SELECT name
FROM stores
WHERE ST_Within(location,
    ST_GeomFromText('POLYGON((-74.0 40.75, -73.97 40.75, -73.97 40.77, -74.0 40.77, -74.0 40.75))', 4326)
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# docker-compose.yml for Redis with geospatial
version: '3'
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data

volumes:
  redis_data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Add locations to a geospatial index
redis-cli
> GEOADD drivers -73.9857 40.7484 "driver:1"
> GEOADD drivers -73.9851 40.7589 "driver:2"
> GEOADD drivers -74.0060 40.7128 "driver:3"

# Find drivers within 3km
> GEORADIUS drivers -73.9855 40.7580 3 km WITHDIST WITHCOORD
1) 1) "driver:2"
   2) "0.1035"
   3) 1) "-73.98509997129440308"
      2) "40.75889866982482244"
2) 1) "driver:1"
   2) "1.0670"
   3) 1) "-73.98570001125335693"
      2) "40.74839866341054442"

# Calculate distance between two points
> GEODIST drivers "driver:1" "driver:2" km
"1.1733"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

┌──────────────────────┐
│   Mobile App / Web   │
└──────────┬───────────┘
           │ Location updates (WebSocket)
┌──────────▼───────────┐
│       Tile38         │ ← Real-time geofencing & pub/sub
└──────────┬───────────┘
           │ Webhook triggers
┌──────────▼───────────┐
│   Application Logic  │ ← Business rules, notifications
└──────────┬───────────┘
           │ Persisted location data
┌──────────▼───────────┐
│      PostGIS         │ ← Spatial analytics, historical queries
└──────────┬───────────┘
           │ Cached geocoding results
┌──────────▼───────────┐
│   Redis Geospatial    │ ← Hot cache for nearby queries
└──────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Integration example: Fleet tracking with Tile38 + PostGIS
import asyncio
import aiohttp
import asyncpg

async def handle_driver_update(driver_id, lat, lon):
    # 1. Update real-time position in Tile38 (WebSocket)
    async with aiohttp.ClientSession() as session:
        await session.post(f"http://tile38:9851/SET fleet {driver_id} POINT {lat} {lon}")
    
    # 2. Persist to PostGIS for historical analysis
    conn = await asyncpg.connect("postgresql://geo:pass@postgis/geospatial")
    await conn.execute("""
        INSERT INTO driver_positions (driver_id, location, timestamp)
        VALUES ($1, ST_SetSRID(ST_MakePoint($2, $3), 4326), NOW())
    """, driver_id, lon, lat)
    await conn.close()

# Tile38 webhook handler (called when driver enters/exits geofence)
async def handle_geofence_event(hook, driver_id, detect):
    if detect == "inside":
        # Driver entered delivery zone - trigger assignment logic
        await assign_delivery(driver_id)
    elif detect == "outside":
        # Driver left zone - update ETA
        await update_delivery_status(driver_id, "en_route")