AWS Network Load Balancer for MCP Server Monitoring

NLB vs ALB: what matters for MCP servers

The MCP specification currently defines two transports: stdio (local process communication) and HTTP with Server-Sent Events (SSE). Remote MCP deployments use SSE exclusively — a long-lived HTTP GET that the server streams events into. This connection lifetime changes which load balancer wins.

For most MCP servers that use SSE transport and run behind a single ECS service, NLB wins on idle timeout and static IPs. If you need host-based routing across multiple MCP endpoints on the same domain, ALB is necessary — NLB doesn't route by hostname or path.

CDK: NLB with IP targets for ECS Fargate

ECS Fargate tasks don't have stable instance IDs — they have private IPs. NLB supports two target types: ip (register by IP, required for Fargate) and instance (register by EC2 instance ID, only for EC2 launch type). The ip target type registers each Fargate task IP directly, avoiding the ENI attachment limitation of instance targets.

import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
import { Duration, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

export function createMcpNlb(
  scope: Construct,
  vpc: ec2.IVpc,
  cluster: ecs.Cluster,
  mcpService: ecs.FargateService,
): elbv2.NetworkLoadBalancer {
  // Allocate one Elastic IP per AZ for static addressing
  const eipA = new ec2.CfnEIP(scope, 'NlbEipA', { domain: 'vpc' });
  const eipB = new ec2.CfnEIP(scope, 'NlbEipB', { domain: 'vpc' });

  const nlb = new elbv2.NetworkLoadBalancer(scope, 'McpNlb', {
    vpc,
    internetFacing: true,
    // Cross-zone load balancing: disable to preserve AZ affinity and avoid
    // inter-AZ data transfer charges on NLB (unlike ALB, NLB charges for cross-AZ bytes)
    crossZoneEnabled: false,
    // Assign fixed Elastic IPs for firewall allowlisting
    vpcSubnets: {
      subnets: vpc.publicSubnets,
      // subnet-to-EIP mapping via L1 override below
    },
  });

  // Target group: IP type for Fargate, 8080 is MCP SSE port
  const targetGroup = new elbv2.NetworkTargetGroup(scope, 'McpTargetGroup', {
    vpc,
    port: 8080,
    protocol: elbv2.Protocol.TCP,
    targetType: elbv2.TargetType.IP,
    // Deregistration delay: how long NLB waits for in-flight SSE streams to complete
    // before removing a draining task; 120s matches ECS container stop timeout
    deregistrationDelay: Duration.seconds(120),
    // Preserve client IP so MCP server receives real caller IP (not NLB IP)
    preserveClientIp: true,
    healthCheck: {
      protocol: elbv2.Protocol.HTTP,
      path: '/health',
      port: '8080',
      interval: Duration.seconds(10),
      healthyThresholdCount: 2,
      unhealthyThresholdCount: 2,
    },
  });

  // TLS listener: NLB terminates TLS, forwards plain TCP to targets
  nlb.addListener('McpTlsListener', {
    port: 443,
    protocol: elbv2.Protocol.TLS,
    certificates: [
      elbv2.ListenerCertificate.fromArn(
        `arn:aws:acm:${Stack.of(scope).region}:${Stack.of(scope).account}:certificate/YOUR_CERT_ID`,
      ),
    ],
    defaultTargetGroups: [targetGroup],
    // TLS 1.2+ with forward secrecy; ECDHE ciphers required for mTLS MCP clients
    sslPolicy: elbv2.SslPolicy.RECOMMENDED_TLS,
  });

  // Also expose plain TCP on port 80 for internal health checks
  nlb.addListener('McpTcpListener', {
    port: 80,
    protocol: elbv2.Protocol.TCP,
    defaultTargetGroups: [targetGroup],
  });

  // Attach ECS service to NLB target group
  mcpService.attachToNetworkTargetGroup(targetGroup);

  return nlb;
}

The preserveClientIp: true setting on the target group causes NLB to send packets with the original source IP. This means the MCP container's security group must allow inbound from the entire client IP range, not just the NLB's IPs. If you're restricting traffic to known AliveMCP probe IPs, this is the right layer to enforce it.

Cross-zone load balancing: default off on NLB

NLB has cross-zone disabled by default; ALB has it enabled by default. The difference matters for both cost and traffic distribution:

For AliveMCP's probe workers behind an NLB, cross-zone is off. The coordinator service (single task in one AZ) uses cross-zone on its internal NLB so all workers can reach it regardless of AZ. Worker-to-coordinator calls are low-volume (registry fetches, not probe results), so cross-AZ transfer costs are negligible.

NLB metrics for MCP server health monitoring

NLB publishes per-target-group and per-load-balancer metrics to CloudWatch. The metrics that signal MCP server problems are different from the metrics that signal NLB infrastructure problems:

AliveMCP creates CloudWatch alarms on HealthyHostCount < 1 (immediate page) and UnHealthyHostCount > 0 for 5 minutes (warning). The NLB health check failure is a leading indicator — AliveMCP's external probe will see failures 10–30 seconds after NLB marks a target unhealthy, but the NLB alarm fires first.

Security group rules for NLB with IP targets

NLB with preserveClientIp: true doesn't use the NLB's IP as the source IP when forwarding packets — it preserves the original client IP. This means your ECS task security group must allow inbound from 0.0.0.0/0 (or the known client CIDR) on the MCP port, not from the NLB security group.

// ECS task security group for NLB with preserved client IP
const mcpTaskSg = new ec2.SecurityGroup(scope, 'McpTaskSg', {
  vpc,
  description: 'MCP server Fargate task',
  allowAllOutbound: true,
});

// NLB preserves source IP — allow from any client (or narrow to your probe CIDR)
mcpTaskSg.addIngressRule(
  ec2.Peer.anyIpv4(),
  ec2.Port.tcp(8080),
  'NLB forward with client IP preservation',
);

// NLB health check probes originate from NLB node IPs in the VPC subnets
// Add the VPC CIDR to allow health check traffic
mcpTaskSg.addIngressRule(
  ec2.Peer.ipv4(vpc.vpcCidrBlock),
  ec2.Port.tcp(8080),
  'NLB health checks from VPC CIDR',
);

If preserveClientIp is false (the default), the source IP seen by the target is the NLB node IP in the VPC subnet — you can restrict the task security group to the VPC CIDR only. For MCP servers that rate-limit by client IP, enabling client IP preservation is essential; for internal probe workers where the source IP is irrelevant, disabling it simplifies security group rules.

AliveMCP probe architecture behind NLB

AliveMCP's own probe infrastructure uses NLB in two places:

1. Internal NLB for probe coordinator: Worker tasks need to fetch the current endpoint registry (batch assignments) from the coordinator. An internal NLB in front of the coordinator provides a stable DNS name (coordinator.alivemcp.internal) that workers use regardless of which AZ the coordinator task is in. Because the coordinator is a single task, the NLB health check serves as a secondary restart trigger — if the coordinator container hangs (health check fails for 20 seconds), NLB marks it unhealthy and a CloudWatch alarm restarts the ECS service.
2. External NLB for the AliveMCP API + dashboard: The public SSE event stream (live uptime feed for registered MCP endpoints) is a long-lived SSE connection from browsers. NLB's 350-second TCP idle timeout handles the case where a browser receives no events (all endpoints are healthy) for several minutes without closing the stream. ALB's 60-second default would disconnect the browser every minute.

For monitored MCP endpoints (the third-party servers AliveMCP probes), the probe worker opens a new HTTP/HTTPS connection for each 60-second probe cycle and closes it after receiving the first valid SSE event or a timeout. These short-lived probe connections don't benefit from NLB vs ALB — what matters is whether the monitored MCP server is behind an NLB, which AliveMCP detects and reports in the endpoint's status page (TCP reset behavior, TLS version, connection establishment latency).