Polyglot Microservices on GKE: MedInsight's Go/Python Architecture

System Overview

MedInsight is a cloud-native medical diagnostics platform processing 100K+ requests/sec with 89%+ automated test coverage and HIPAA-compliant reasoning powered by Gemma 2. This deep-dive explores the architectural decisions behind our polyglot microservices design—Go for high-performance data processing, Python for ML inference—orchestrated on Google Kubernetes Engine.

Architecture Principles

The Polyglot Decision

Go Services: High-Performance Data Layer

API Gateway Implementation

package gateway

import (
    "context"
    "net/http"
    "github.com/gin-gonic/gin"
    "google.golang.org/api/pubsub/v1"
)

type APIGateway struct {
    pubsubClient *pubsub.Service
    queryService *QueryService
    reasoningService *ReasoningServiceClient
}

func (g *APIGateway) HandleDiagnosticRequest(c *gin.Context) {
    var req DiagnosticRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    // Validate HIPAA compliance
    if !g.validateHIPAACompliance(req) {
        c.JSON(http.StatusForbidden, gin.H{"error": "HIPAA validation failed"})
        return
    }
    
    // Route to appropriate service
    ctx := context.Background()
    
    // High-throughput data ingestion via Go service
    if req.Type == "data_ingestion" {
        result, err := g.handleDataIngestion(ctx, req)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, result)
        return
    }
    
    // ML reasoning via Python service (async via Pub/Sub)
    if req.Type == "reasoning" {
        messageID, err := g.publishToReasoningQueue(ctx, req)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusAccepted, gin.H{"message_id": messageID})
        return
    }
}

func (g *APIGateway) handleDataIngestion(ctx context.Context, req DiagnosticRequest) (*IngestionResult, error) {
    // Go service handles 100K+ req/sec with goroutines
    result := make(chan *IngestionResult, 1)
    errChan := make(chan error, 1)
    
    go func() {
        // Concurrent processing with worker pool
        processed, err := g.processConcurrently(ctx, req.Data)
        if err != nil {
            errChan <- err
            return
        }
        result <- processed
    }()
    
    select {
    case res := <-result:
        return res, nil
    case err := <-errChan:
        return nil, err
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

Data Ingestion Service

package ingestion

import (
    "context"
    "sync"
    "gorm.io/gorm"
)

type DataIngestionService struct {
    db          *gorm.DB
    workerPool  *WorkerPool
    auditLogger *AuditLogger
}

func (s *DataIngestionService) ProcessBatch(ctx context.Context, batch []MedicalRecord) error {
    // HIPAA-compliant batch processing
    var wg sync.WaitGroup
    semaphore := make(chan struct{}, 100) // Limit concurrency
    
    for _, record := range batch {
        wg.Add(1)
        go func(rec MedicalRecord) {
            defer wg.Done()
            semaphore <- struct{}{}
            defer func() { <-semaphore }()
            
            // Encrypt PHI before storage
            encrypted, err := s.encryptPHI(rec)
            if err != nil {
                s.auditLogger.LogError(ctx, rec.ID, err)
                return
            }
            
            // Store with audit trail
            if err := s.db.WithContext(ctx).Create(&encrypted).Error; err != nil {
                s.auditLogger.LogError(ctx, rec.ID, err)
                return
            }
            
            s.auditLogger.LogAccess(ctx, rec.ID, "CREATE")
        }(record)
    }
    
    wg.Wait()
    return nil
}

Python Services: ML Inference Layer

Gemma 2 Reasoning Service

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
from google.cloud import pubsub_v1
import json
from typing import Dict, Any

class ReasoningService:
    def __init__(self):
        self.tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")
        self.model = AutoModelForCausalLM.from_pretrained(
            "google/gemma-2-9b",
            torch_dtype=torch.bfloat16,
            device_map="auto"
        )
        self.pubsub_publisher = pubsub_v1.PublisherClient()
        self.topic_path = self.pubsub_publisher.topic_path(
            "medinsight-project", "reasoning-results"
        )
    
    def reason_about_medical_data(self, patient_data: Dict[str, Any], query: str) -> str:
        """
        HIPAA-compliant reasoning: No PHI persisted in model memory.
        """
        # Construct prompt with de-identified data
        prompt = self.construct_reasoning_prompt(patient_data, query)
        
        # Generate reasoning
        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
        outputs = self.model.generate(
            **inputs,
            max_new_tokens=512,
            temperature=0.7,
            do_sample=True
        )
        
        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Publish result asynchronously (no PHI in message)
        result_id = self.publish_result(response, patient_data.get("request_id"))
        
        return result_id
    
    def construct_reasoning_prompt(self, patient_data: Dict, query: str) -> str:
        """Construct prompt ensuring no PHI leakage."""
        # De-identify data before prompt construction
        deidentified = self.deidentify_data(patient_data)
        
        return f"""
        Given the following medical data (de-identified):
        {json.dumps(deidentified, indent=2)}
        
        Answer the following query: {query}
        
        Provide a reasoned medical analysis following HIPAA guidelines.
        """

GKE Deployment Strategy

Multi-Language Pod Configuration

# Go service deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: medinsight-ingestion-go
spec:
  replicas: 10
  template:
    spec:
      containers:
      - name: ingestion
        image: gcr.io/medinsight/ingestion-go:latest
        resources:
          requests:
            cpu: "500m"
            memory: "512Mi"
          limits:
            cpu: "2000m"
            memory: "2Gi"
        env:
        - name: DB_HOST
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: host
        - name: HIPAA_MODE
          value: "strict"

---
# Python service deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: medinsight-reasoning-python
spec:
  replicas: 5
  template:
    spec:
      containers:
      - name: reasoning
        image: gcr.io/medinsight/reasoning-python:latest
        resources:
          requests:
            cpu: "2000m"
            memory: "8Gi"
            nvidia.com/gpu: 1  # GPU for Gemma 2
          limits:
            cpu: "4000m"
            memory: "16Gi"
            nvidia.com/gpu: 1
        env:
        - name: MODEL_PATH
          value: "/models/gemma-2-9b"
        - name: HIPAA_MODE
          value: "strict"

Testing & Quality Assurance

Test Coverage Strategy

// Go service test example
func TestDataIngestionHIPAACompliance(t *testing.T) {
    service := NewDataIngestionService(mockDB, mockAuditLogger)
    
    testCases := []struct {
        name    string
        record  MedicalRecord
        wantErr bool
    }{
        {
            name: "valid encrypted record",
            record: MedicalRecord{
                ID:      "test-123",
                PHI:     encrypt("John Doe"),
                Data:    []byte("test data"),
            },
            wantErr: false,
        },
        {
            name: "unencrypted PHI should fail",
            record: MedicalRecord{
                ID:      "test-456",
                PHI:     "John Doe", // Not encrypted!
                Data:    []byte("test data"),
            },
            wantErr: true,
        },
    }
    
    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            err := service.ProcessRecord(context.Background(), tc.record)
            if (err != nil) != tc.wantErr {
                t.Errorf("ProcessRecord() error = %v, wantErr %v", err, tc.wantErr)
            }
        })
    }
}

Performance Metrics

• Throughput: 100K+ requests/sec sustained (Go services)
• Test Coverage: 89%+ automated test coverage
• Reasoning Latency: p95 < 3 seconds (Gemma 2 inference)
• API Latency: p95 < 200ms (Go gateway)
• HIPAA Compliance: 100% audit logging, zero PHI leakage
• Uptime: 99.9% availability across GKE cluster

Key Learnings

1. Polyglot Architecture: Choosing the right language for each service's domain maximizes performance while accepting operational complexity.

2. HIPAA Compliance: Strict data isolation between Go (data) and Python (reasoning) services prevents PHI leakage in model memory.

3. Pub/Sub Decoupling: Asynchronous communication via Google Pub/Sub enables fault tolerance and independent scaling.

4. Test Coverage: 89%+ coverage across polyglot services requires language-specific testing strategies but ensures reliability.

5. GKE Orchestration: Kubernetes handles multi-language deployments seamlessly, but resource allocation must account for language-specific characteristics (Go: CPU-bound, Python: memory/GPU-bound).