Telecom Protocols

5G UE State Machine with AWS Step Functions

Event-driven finite state machine for managing 5G User Equipment (UE) registration and connection states, orchestrated using AWS Step Functions and adhering to 3GPP TS 23.502 specifications.

Client / Context

5G Mobile Network Operator

Timeline

Q3 2024 - Q4 2024

Role

Lead Developer & 5G Architect

Technology Stack

AWS Step Functions AWS Lambda EventBridge DynamoDB Node.js TypeScript CloudWatch 3GPP Standards

Project Overview

Developed a serverless finite state machine to manage 5G User Equipment (UE) lifecycle states including Registration Management (RM) and Connection Management (CM) states per 3GPP specifications.

The system orchestrates complex state transitions triggered by network events (attach, detach, idle timeout, paging) using AWS Step Functions, ensuring deterministic behavior and full audit trails.

Handles over 100,000 UE state transitions per day with sub-second latency and complete compliance with 3GPP TS 23.502 state models.

The Challenge

Problem Statement

This project addressed multiple critical technical challenges:

1. Complex State Transition Logic

5G UE can be in multiple states simultaneously (RM-REGISTERED + CM-IDLE, or RM-DEREGISTERED + CM-CONNECTED). Managing these orthogonal state machines with proper event handling and race condition prevention required careful architectural design.

2. Event Ordering and Idempotency

Network events can arrive out of order or be duplicated due to retries. The state machine must ensure idempotent processing and maintain event sequence numbers to prevent invalid state transitions.

Solution Architecture

stateDiagram-v2 [*] --> RM_DEREGISTERED RM_DEREGISTERED --> RM_REGISTERED: Registration Request RM_REGISTERED --> RM_DEREGISTERED: Deregistration state RM_REGISTERED { [*] --> CM_IDLE CM_IDLE --> CM_CONNECTED: Service Request / MO Data CM_CONNECTED --> CM_IDLE: Inactivity Timer CM_CONNECTED --> CM_CONNECTED: Data Transfer } note right of RM_REGISTERED: Connection Management
within Registration

Key Features & Implementation

Registration Management (RM) States: RM-DEREGISTERED, RM-REGISTERED with proper authentication flows
Connection Management (CM) States: CM-IDLE, CM-CONNECTED with inactivity timers and paging support
Event-Driven Architecture: EventBridge triggers state machine executions based on network events
Step Functions Orchestration: Visual state machine definition with automatic retry and error handling
State Persistence: DynamoDB stores current UE state with optimistic locking for concurrent updates
Audit Trail: Complete CloudWatch logging of all state transitions with event metadata
Idempotency: Execution tokens and sequence numbers prevent duplicate processing
Timeout Handling: Automatic state transitions on inactivity (CM-CONNECTED → CM-IDLE after 20s)

Implementation Highlights

1. Step Functions State Machine Definition

AWS Step Functions state machine for UE Registration Management:

state-machine/ue-registration-sm.json

{
  "Comment": "5G UE Registration Management State Machine",
  "StartAt": "CheckCurrentState",
  "States": {
    "CheckCurrentState": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789:function:GetUEState",
      "Next": "EvaluateEvent"
    },
    "EvaluateEvent": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.event.type",
          "StringEquals": "REGISTRATION_REQUEST",
          "Next": "ProcessRegistration"
        },
        {
          "Variable": "$.event.type",
          "StringEquals": "SERVICE_REQUEST",
          "Next": "ProcessServiceRequest"
        },
        {
          "Variable": "$.event.type",
          "StringEquals": "DEREGISTRATION",
          "Next": "ProcessDeregistration"
        },
        {
          "Variable": "$.event.type",
          "StringEquals": "INACTIVITY_TIMEOUT",
          "Next": "ProcessTimeout"
        }
      ],
      "Default": "InvalidEvent"
    },
    "ProcessRegistration": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789:function:HandleRegistration",
      "Next": "UpdateStateToRegistered"
    },
    "UpdateStateToRegistered": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789:function:UpdateUEState",
      "Parameters": {
        "ueId.$": "$.ueId",
        "newState": "RM-REGISTERED",
        "connectionState": "CM-IDLE"
      },
      "Next": "Success"
    },
    "Success": {
      "Type": "Succeed"
    },
    "InvalidEvent": {
      "Type": "Fail",
      "Error": "InvalidEventType",
      "Cause": "Unknown event type received"
    }
  }
}

2. UE State Manager Lambda Function

Lambda function for managing UE state transitions:

src/state-manager/ueStateManager.ts

import { DynamoDBClient, UpdateItemCommand } from '@aws-sdk/client-dynamodb';

interface UEState {
  ueId: string;
  registrationState: 'RM-DEREGISTERED' | 'RM-REGISTERED';
  connectionState: 'CM-IDLE' | 'CM-CONNECTED';
  lastUpdate: number;
  sequenceNumber: number;
}

export class UEStateManager {
  private dynamoDb: DynamoDBClient;
  private tableName: string;

  constructor() {
    this.dynamoDb = new DynamoDBClient({});
    this.tableName = process.env.UE_STATE_TABLE!;
  }

  async transitionState(
    ueId: string,
    newRegistrationState: string,
    newConnectionState: string,
    eventSeqNum: number
  ): Promise<UEState> {
    // Optimistic locking with condition expression
    const command = new UpdateItemCommand({
      TableName: this.tableName,
      Key: { ueId: { S: ueId } },
      UpdateExpression: `
        SET registrationState = :regState,
            connectionState = :connState,
            lastUpdate = :timestamp,
            sequenceNumber = :seqNum
      `,
      ConditionExpression: 'sequenceNumber < :seqNum',
      ExpressionAttributeValues: {
        ':regState': { S: newRegistrationState },
        ':connState': { S: newConnectionState },
        ':timestamp': { N: Date.now().toString() },
        ':seqNum': { N: eventSeqNum.toString() }
      },
      ReturnValues: 'ALL_NEW'
    });

    const result = await this.dynamoDb.send(command);
    return this.mapDynamoToState(result.Attributes!);
  }

  async validateTransition(
    currentState: UEState,
    event: { type: string }
  ): boolean {
    const transitions = {
      'RM-DEREGISTERED': {
        'REGISTRATION_REQUEST': 'RM-REGISTERED'
      },
      'RM-REGISTERED': {
        'CM-IDLE': {
          'SERVICE_REQUEST': 'CM-CONNECTED',
          'DEREGISTRATION': 'RM-DEREGISTERED'
        },
        'CM-CONNECTED': {
          'INACTIVITY_TIMEOUT': 'CM-IDLE',
          'DEREGISTRATION': 'RM-DEREGISTERED'
        }
      }
    };

    // Validate transition is allowed per 3GPP specs
    return this.isValidTransition(currentState, event, transitions);
  }

  private isValidTransition(
    state: UEState,
    event: { type: string },
    transitions: any
  ): boolean {
    if (state.registrationState === 'RM-DEREGISTERED') {
      return event.type === 'REGISTRATION_REQUEST';
    }
    
    const cmTransitions = transitions[state.registrationState]?.[state.connectionState];
    return cmTransitions && event.type in cmTransitions;
  }

  private mapDynamoToState(item: any): UEState {
    return {
      ueId: item.ueId.S,
      registrationState: item.registrationState.S as any,
      connectionState: item.connectionState.S as any,
      lastUpdate: parseInt(item.lastUpdate.N),
      sequenceNumber: parseInt(item.sequenceNumber.N)
    };
  }
}

Results & Impact

Outcomes Achieved

Processing 100,000+ state transitions per day with 99.99% success rate
Average state transition latency: 250ms including DynamoDB updates
Zero invalid state transitions due to comprehensive validation logic
Complete audit trail: All state changes logged with timestamps and events
Cost efficiency: $50/month for 3M state transitions using serverless architecture
3GPP Compliance: Full adherence to TS 23.502 Registration and Connection Management procedures

Technical Insights & Best Practices

5G State Machine Design

3GPP TS 23.502 defines orthogonal state machines: RM and CM states are independent
CM states only exist when RM-REGISTERED; deregistration immediately transitions CM to undefined
Inactivity timer (typically 10-20 seconds) manages CM-CONNECTED → CM-IDLE transitions
Paging is only sent to UEs in CM-IDLE state to locate them for mobile-terminated traffic

AWS Step Functions Best Practices

Use execution names as idempotency tokens to prevent duplicate state machine runs
Set appropriate timeouts for each state to prevent stuck executions
Leverage Choice states for branching logic instead of Lambda-based decisions
Use Step Functions Express Workflows for high-throughput, low-latency requirements

Standards & References

3GPP TS 23.502: Procedures for the 5G System (5GS)
3GPP TS 24.501: Non-Access-Stratum (NAS) protocol for 5GS
3GPP TS 23.501: System architecture for the 5G System (5GS)
AWS Well-Architected Framework: Operational Excellence Pillar

Back to Portfolio