Scaling

# docker-compose.scale.yml
services:
  api:
    image: my-api:latest
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '1'
          memory: 512M
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=${REDIS_URL}
 
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    depends_on:
      - api

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: apso-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: apso-api
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80

# pgbouncer.ini
[databases]
myapp = host=postgres port=5432 dbname=myapp
 
[pgbouncer]
pool_mode = transaction
max_client_conn = 1000
default_pool_size = 20
min_pool_size = 5
reserve_pool_size = 5

// src/config/database.config.ts
export const databaseConfig = {
  type: 'postgres',
  url: process.env.DATABASE_URL,
  extra: {
    max: 20,                    // Max pool size per instance
    idleTimeoutMillis: 30000,   // Close idle connections
    connectionTimeoutMillis: 2000,
  },
  logging: process.env.NODE_ENV === 'development',
};

// Multiple database connections
@Module({
  imports: [
    TypeOrmModule.forRoot({
      name: 'default',  // Primary for writes
      url: process.env.DATABASE_URL,
    }),
    TypeOrmModule.forRoot({
      name: 'replica',  // Replica for reads
      url: process.env.DATABASE_REPLICA_URL,
    }),
  ],
})
export class DatabaseModule {}
 
// Use replica for read operations
@Injectable()
export class ReportingService {
  constructor(
    @InjectRepository(Order, 'replica')
    private readonly orderRepo: Repository<Order>,
  ) {}
}

// src/cache/cache.module.ts
import { CacheModule } from '@nestjs/cache-manager';
import * as redisStore from 'cache-manager-redis-store';
 
@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: process.env.REDIS_HOST,
      port: process.env.REDIS_PORT,
      ttl: 300, // 5 minutes default
    }),
  ],
})
export class CacheConfigModule {}

// Cache at controller level
@Get()
@UseInterceptors(CacheInterceptor)
@CacheTTL(60) // 1 minute
findAll(@Query() query: FindAllQuery) {
  return this.service.findAll(query);
}
 
// Cache at service level
@Injectable()
export class ProjectsService {
  constructor(
    @Inject(CACHE_MANAGER) private cacheManager: Cache,
  ) {}
 
  async findOne(id: string): Promise<Project> {
    const cacheKey = `project:${id}`;
    let project = await this.cacheManager.get<Project>(cacheKey);
 
    if (!project) {
      project = await this.repository.findOne({ where: { id } });
      await this.cacheManager.set(cacheKey, project, 300);
    }
 
    return project;
  }
}

// Invalidate on updates
async update(id: string, dto: UpdateProjectDto): Promise<Project> {
  const project = await this.repository.save({ id, ...dto });
  await this.cacheManager.del(`project:${id}`);
  await this.cacheManager.del(`projects:list`);
  return project;
}

// Avoid N+1 queries
async findAllWithTasks(): Promise<Project[]> {
  return this.repository.find({
    relations: ['tasks'],  // Join in single query
  });
}

// Select only needed fields
const projects = await this.repository
  .createQueryBuilder('project')
  .select(['project.id', 'project.name'])
  .where('project.organizationId = :orgId', { orgId })
  .getMany();

@Entity('projects')
@Index(['organizationId'])
@Index(['createdAt'])
@Index(['organizationId', 'status'])
export class Project {
  // ...
}

// Prometheus metrics
import { PrometheusModule, makeHistogramProvider } from '@willsoto/nestjs-prometheus';
 
@Module({
  imports: [
    PrometheusModule.register({
      path: '/metrics',
      defaultMetrics: { enabled: true },
    }),
  ],
  providers: [
    makeHistogramProvider({
      name: 'http_request_duration_seconds',
      help: 'Duration of HTTP requests in seconds',
      labelNames: ['method', 'route', 'status'],
    }),
  ],
})
export class MetricsModule {}

// Logging middleware with timing
@Injectable()
export class LoggingMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const start = Date.now();
 
    res.on('finish', () => {
      const duration = Date.now() - start;
      console.log({
        method: req.method,
        url: req.url,
        status: res.statusCode,
        duration: `${duration}ms`,
      });
    });
 
    next();
  }
}