Partner Training

PureLoad 5G Core Training

Partner training materials for testing 5G Service-Based Interfaces. Learn to simulate AMF, UDM, AUSF with HTTP/2 and TLS.

Quick Start (15-Minute Demo)

New to PureLoad? Start with our guided demo that walks through a complete AMF/UDM/AUSF authentication flow with TLS encryption.

What You'll Learn

5G Core SBA basics (HTTP/2 + TLS)
Simulating AMF as client
AUSF/UDM as servers
5G-AKA authentication flow

Demo Environment

SSH: pureload@192.168.122.10

API: http://192.168.122.10:8089

VM Specs: 40GB RAM, 30GB disk, KVM

Full Training Course (60 Minutes)

Module	Duration	Content
5G Core SBA Overview	5 min	HTTP/2, TLS, Service-Based Interfaces vs 4G SS7/Diameter
Live Demo	15 min	Run AMF/UDM/AUSF simulation, analyze results
Hands-On Exercise	20 min	Modify IMSI, add delays, re-run tests
Scale Testing	15 min	Load testing with 5,000 parallel flows
Integration	5 min	REST API and CI/CD integration

AMF/UDM/AUSF Authentication Flow

Simulate a complete 5G-AKA authentication with TLS encryption on all HTTP/2 connections.

Network Functions

AMF (Client) — initiates authentication on 172.16.178.10
AUSF (Server, port 29509) — handles 5G-AKA authentication
UDM (Server, port 29503) — provides subscriber NSSAI data

Call Flow Diagram

┌─────────┐         TLS:29509          ┌─────────┐         TLS:29503          ┌─────────┐
│   AMF   │  ═══════════════════════════►│  AUSF   │                              │   UDM   │
│ (Client)│  ◄═══════════════════════════│ (Server)│                              │ (Server)│
│172.16.  │                              │172.16.  │                              │172.16.  │
│178.10   │                              │178.10   │                              │178.10   │
└────┬────┘                              └─────────┘                              └────┬────┘
     │                                                                                  │
     │  1. POST /nausf-auth/v1/ue-authentications                                       │
     │     Body: {supiOrSuci, servingNetworkName}                                       │
     │  ═══════════════════════════════════════════►                                     │
     │                                                                                  │
     │  ◄═══════════════════════════════════════════                                    │
     │     200 OK {authResult, kseaf}                                                   │
     │                                                                                  │
     │  2. PUT /nausf-auth/v1/ue-authentications/{suci}/5g-aka-confirmation             │
     │     Body: {resStar}                                                              │
     │  ════════════════════════════════════════════►                                    │
     │                                                                                  │
     │  ◄════════════════════════════════════════════                                   │
     │     200 OK {authResult, supi, kseaf}                                             │
     │                                                                                  │
     │  3. GET /nudm-sdm/v1/imsi-2089300007487/nssai?plmnid=20893                       │
     │  ═══════════════════════════════════════════════════════════════════════════════►  │
     │                                                                                  │
     │  ◄══════════════════════════════════════════════════════════════════════════════  │
     │     200 OK {deliveryStatus: "DELIVERED_TO_UE"}                                   │

Authentication Details

Parameter	Value
SUCI	`suci-0-208-93-0-0-0-00007487`
SUPI/IMSI	`imsi-2089300007487`
PLMN	`20893 (MCC=208, MNC=93)`
Serving Network	`5G:mnc093.mcc208.3gppnetwork.org`
RES*	`d242094fcb1394c2d2856ea0a60f3d1f`
KSEAF	`058758e6b642d35042058016c673a8318c2c031c5d4cdbef19ef1df36a213ba8`

Simulation Results

Overall Statistics

Metric	Value	Status
Tasks Executed	10	✓
Success Rate	100% (10/10)	✓
Failed Tasks	0	✓
Timeout Tasks	0	✓
Tasks/Second	0.88	✓
Transactions	4 (3 auth + 1 SDM)	✓
Transactions/Second	0.35	✓
Data Volume	10.5 kbits	✓

Per-Scenario Breakdown

NF	Response Time	Transactions	Role
AMF	832 ms	3	Client (initiates requests)
UDM	7,059 ms	1	Server (SDM responses)
AUSF	11,316 ms	0	Server (auth responses)

REST API Integration

Create and Run Simulation

# Create simulation from template
curl -s -X POST -H 'Content-Type: application/json' \
  -d '{"name":"AMF Test","templatePath":"/v1/template/100"}' \
  http://192.168.122.10:8089/v1/simulation

# Start execution
curl -s -X PUT -H 'Content-Type: application/json' \
  -d '{"state":"Running"}' \
  http://192.168.122.10:8089/v1/simulation/100

# Get results
curl -s http://192.168.122.10:8089/v1/simulation/100/resulttotals

Python Integration Example

import requests
import time

def run_amf_auth_test():
    # Create simulation
    response = requests.post(
        'http://192.168.122.10:8089/v1/simulation',
        json={
            'name': 'Automated AMF Test',
            'templatePath': '/v1/template/100'
        }
    )
    sim_id = response.json()['id']
    
    # Start it
    requests.put(
        f'http://192.168.122.10:8089/v1/simulation/{sim_id}',
        json={'state': 'Running'}
    )
    
    # Poll for completion
    while True:
        status = requests.get(
            f'http://192.168.122.10:8089/v1/simulation/{sim_id}'
        ).json()
        if status['state'] == 'Done':
            return requests.get(
                f'http://192.168.122.10:8089/v1/simulation/{sim_id}/resulttotals'
            ).json()
        time.sleep(5)

CI/CD Integration (GitHub Actions)

name: 5G Core Test
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run PureLoad Simulation
        run: |
          RESULT=$(curl -s http://test-env:8089/v1/simulation/100/resulttotals)
          OK_RATE=$(echo $RESULT | jq '.percentageOK')
          if [ "$OK_RATE" != "100" ]; then exit 1; fi

Scale Testing

Same authentication flow, but with 5,000 parallel instances at 100 TPS.

Feature	Functional	Load
Instances	1	5,000
Distribution	burst	rampup
Duration	~10 sec	60 sec
Rate	~1 TPS	100 TPS
Purpose	Validate flow	Test capacity

Proves: PureLoad scales from single requests to thousands. Same PLC logic, different parameters. Production-ready load patterns.

Hands-On Exercises

Exercise 1: Modify IMSI

Change the SUCI/IMSI in the PLC file and re-run.

Before: imsi-2089300007487

After: imsi-2089300009999

Question: Does UDM respond differently? Why?

Exercise 2: Add Delay

Introduce latency to see impact on metrics.

Change: Sleep 10s → 30s in AUSF

Observe: Response time, TPS changes

Verify: Success rate remains 100%

What This Proves to Partners

1. NF Development Testing

Test your AMF against realistic AUSF/UDM without real 5G core deployment.

2. Integration Testing

Connect PureLoad to your real NFs. Validate interfaces before production.

3. Load & Capacity Testing

1 → 5,000 → 50,000 parallel flows. Find breaking points before launch.

4. Failure Scenario Testing

Simulate slow/failing peers. Test retry logic and timeouts.

5G Core Terminology

Term	Definition
AMF	Access and Mobility Management Function
AUSF	Authentication Server Function
UDM	Unified Data Management
SBI	Service-Based Interface (HTTP/2 API between NFs)
SUCI	Subscription Concealed Identifier (encrypted IMSI)
SUPI	Subscription Permanent Identifier (IMSI)
5G-AKA	5G Authentication and Key Agreement
KSEAF	Key for Security Anchor Function
NSSAI	Network Slice Selection Assistance Information
PLC	PureLoad Configuration (XML test definition)

Support & Resources

Files from Today's Session

PARTNER_TRAINING_KIT.md — 60-minute training guide
PARTNER_DEMO_SCRIPT.md — 15-minute demo script
PARTNER_PRESENTATION.md — 14-slide deck
AMF_UDM_AUSF_KDDIv_Functional_TLS.plc — TLS test (24,190 bytes)
AMF_UDM_AUSF_KDDIv_Load.plc — Load test variant

VM Environment

Host: 192.168.122.10

User: pureload

Specs: KVM VM, 40GB RAM, Ubuntu 22.04.5 LTS

Service: simulation-control on port 8089

Training Checklist

Run the 15-minute demo
Complete hands-on exercises
Plan API/CI-CD integration
Schedule advanced training (custom protocols)