HTTP sebességteszt REST SMS szolgáltatásokhoz

Szükséged van a HTTP-alapú SMS szolgáltatásod teljesítményének mérésére? A REST SMS szolgáltatásokhoz készült HTTP sebességteszt egy hatékony eszköz, amely a JSON/REST API végpontok sebességét és megbízhatóságát értékeli. Ez a letölthető segédprogram lehetővé teszi nagy mennyiségű SMS kérés szimulálását, a sikerességi arányok nyomon követését és a másodpercenkénti kérések számítását – segítve a szerver teljesítményének optimalizálását terhelés alatt. Legyen szó helyi fejlesztői környezet terheléses teszteléséről vagy éles SMS átjáró teljesítményének méréséről, ez az eszköz pontos mérőszámokat nyújt a teljes kérések számáról, az egyidejű kapcsolatokról és a HTTP Keep-Alive hatékonyságáról. Töltsd le a készen használható C# megoldást, vagy integráld a mellékelt forráskódot a tesztelési folyamatodba a pontos API teljesítményelemzés érdekében.

Letöltés

HttpSpeedTest.zip

Példa használatra

1. ábra - A sebességteszt eszköz használata

Forráskód

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static readonly Random random = new Random();
    static readonly string[] sampleMessages = {
        "Hello, this is a test message.",
        "Performance testing HTTP server capabilities.",
        "Measuring requests per second for JSON API.",
        "Random message content for load testing.",
        "Another test message with different content.",
        "Checking server capacity under load.",
        "How many requests can the server handle?",
        "Stress testing the SMS API endpoint.",
        "This message is automatically generated.",
        "Final test message in the sample set."
    };

    static async Task Main(string[] args)
    {
        Console.WriteLine("HTTP Server JSON API Performance Tester");
        Console.WriteLine("---------------------------------------");

        if (args.Length < 3)
        {
            Console.WriteLine("Usage: Program    [useKeepAlive]");
            Console.WriteLine("Example: Program http://198.50.122.178:8080 1000 50 true");
            Console.WriteLine("Example: Program https://api.example.com/sms 5000 100 false");
            Console.WriteLine("Example: Program http://localhost/innotest/innotest.php 50 10 false");
        
            return;
        }

        string baseUrl = args[0];
        if (!Uri.TryCreate(baseUrl, UriKind.Absolute, out Uri uriResult) ||
            (uriResult.Scheme != Uri.UriSchemeHttp && uriResult.Scheme != Uri.UriSchemeHttps))
        {
            Console.WriteLine("Invalid base URL. Must be a valid HTTP or HTTPS URL.");
            return;
        }

        if (!int.TryParse(args[1], out int totalRequests) || totalRequests <= 0)
        {
            Console.WriteLine("Invalid totalRequests value. Must be a positive integer.");
            return;
        }

        if (!int.TryParse(args[2], out int concurrentRequests) || concurrentRequests <= 0)
        {
            Console.WriteLine("Invalid concurrentRequests value. Must be a positive integer.");
            return;
        }

        bool useKeepAlive = args.Length > 3 && bool.TryParse(args[3], out bool keepAlive) && keepAlive;

        Console.WriteLine($"Test Parameters:");
        Console.WriteLine($"- Base URL: {baseUrl}");
        Console.WriteLine($"- Total Requests: {totalRequests}");
        Console.WriteLine($"- Concurrent Requests: {concurrentRequests}");
        Console.WriteLine($"- HTTP Keep-Alive: {(useKeepAlive ? "Enabled" : "Disabled")}");
        Console.WriteLine();

        var httpClientHandler = new HttpClientHandler
        {
            UseProxy = false,
            MaxConnectionsPerServer = concurrentRequests
        };

        var httpClient = new HttpClient(httpClientHandler)
        {
            Timeout = TimeSpan.FromSeconds(30),
            BaseAddress = new Uri(baseUrl)
        };

        if (useKeepAlive)
        {
            httpClient.DefaultRequestHeaders.ConnectionClose = false;
            httpClient.DefaultRequestHeaders.Connection.Add("keep-alive");
        }
        else
        {
            httpClient.DefaultRequestHeaders.ConnectionClose = true;
        }

        httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(
         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "+
         "(KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36");
        httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");

        var stopwatch = Stopwatch.StartNew();
        var tasks = new List(concurrentRequests);
        var completedRequests = 0;
        var successfulRequests = 0;
        var failedRequests = 0;

        Console.WriteLine("Starting test...");

        var semaphore = new System.Threading.SemaphoreSlim(concurrentRequests, concurrentRequests);
        var jsonOptions = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = false
        };

        for (int i = 0; i < totalRequests; i++)
        {
            await semaphore.WaitAsync();

            tasks.Add(Task.Run(async () =>
            {
                try
                {
                    var requestData = new
                    {
                        sender = "+0000000",
                        gsm = GenerateRandomPhoneNumber(),
                        text = GetRandomMessage(),
                        usrClient = "Pruebas",
                        pasClient = "Pruebas"
                    };

                    var json = JsonSerializer.Serialize(requestData, jsonOptions);
                    var content = new StringContent(json, Encoding.UTF8, "application/json");

                    var response = await httpClient.PostAsync(baseUrl, content);

                    System.Threading.Interlocked.Increment(ref completedRequests);

                    if (response.IsSuccessStatusCode)
                    {
                        System.Threading.Interlocked.Increment(ref successfulRequests);
                    }
                    else
                    {
                        System.Threading.Interlocked.Increment(ref failedRequests);
                        Console.WriteLine($"Request failed with status: {response.StatusCode}");
                    }
                }
                catch (Exception ex)
                {
                    System.Threading.Interlocked.Increment(ref completedRequests);
                    System.Threading.Interlocked.Increment(ref failedRequests);
                    Console.WriteLine($"Request failed: {ex.Message}");
                }
                finally
                {
                    semaphore.Release();
                }
            }));
        }

        await Task.WhenAll(tasks);
        stopwatch.Stop();

        Console.WriteLine("\nTest completed!");
        Console.WriteLine($"Total time: {stopwatch.Elapsed.TotalSeconds:F2} seconds");
        Console.WriteLine($"Completed requests: {completedRequests}");
        Console.WriteLine($"Successful requests: {successfulRequests}");
        Console.WriteLine($"Failed requests: {failedRequests}");
        Console.WriteLine($"Requests per second: {totalRequests / stopwatch.Elapsed.TotalSeconds:F2}");
    }

    static string GenerateRandomPhoneNumber()
    {
        return $"+{random.Next(100, 999)}{random.Next(1000000, 9999999)}";
    }

    static string GetRandomMessage()
    {
        return sampleMessages[random.Next(sampleMessages.Length)];
    }
}

Kód magyarázata

1. Áttekintés

Ez a C# konzolalkalmazás terheléses tesztet végez egy HTTP(S) SMS API végponton párhuzamos JSON kérések küldésével, miközben méri a teljesítmény metrikákat, mint például:

  • Kérések másodpercenként (RPS)
  • Sikerességi/hibás arányok
  • Teljes végrehajtási idő

2. Főbb összetevők

A. Beállítás és konfiguráció

Véletlenszerű adatgenerálás:

  • sampleMessages: Előre definiált SMS szövegminták valósághű teszteléshez.
  • GenerateRandomPhoneNumber(): Véletlenszerű telefonszámokat generál (pl. +1234567890).
  • GetRandomMessage(): Véletlenszerű üzenetet választ a sampleMessages tömbből.

Parancssori argumentumok:

Program <baseUrl> <totalRequests> <concurrentRequests> [useKeepAlive]
  • Ellenőrzi a bemeneteket (URL formátum, pozitív egész számok a kérések számához).
  • Konfigurálja a HTTP kliens beállításokat (időtúllépés, keep-alive, user-agent).

B. HTTP kliens konfiguráció

HttpClient testreszabása:

  • MaxConnectionsPerServer: Korlátozza a szerverrel párhuzamos kapcsolatokat.
  • ConnectionClose/keep-alive: Váltogatja a HTTP állandó kapcsolatokat.
  • Időtúllépés: 30 másodperc kérésenként.
  • Fejlécek: Beállítja a User-Agent és Accept: application/json értékeket.

C. Terheléses teszt végrehajtása

Párhuzamosság szabályozása:

  • SemaphoreSlim segítségével szabályozza a párhuzamos kéréseket (pl. 50 egyszerre).
  • Async/await (Task.Run) a nem blokkoló I/O műveletekhez.

Kérési folyamat:

  1. JSON adatot szerializál véletlenszerű telefonszámokkal/üzenetekkel: 
    {
    "sender": "+0000000",
    "gsm": "+1234567890",
    "text": "Hello, this is a test message.",
    "usrClient": "Pruebas",
    "pasClient": "Pruebas"
}
  2. POST kérést küld a megadott végpontra.
  3. Nyomon követi a sikeres/hibás kéréseket Interlocked segítségével szálbiztos számlálókkal.

D. Metrikák és jelentéskészítés

  • Stopwatch: Méri a teljes teszt időtartamát.
  • Kimeneti metrikák:
    • Teljes eltelt idő.
    • Befejezett/sikeres/hibás kérések.
    • Kérések másodpercenként (RPS): totalRequests / elapsedTime.

3. Technikai kiemelések

  • Szálbiztonság:
    • Interlocked.Increment biztosítja az atomi számláló frissítést szálak között.
    • SemaphoreSlim megakadályozza a szerver vagy kliens túlterhelését.
  • Hibakezelés:
    • Elkapja a kivételeket (pl. időtúllépés, hálózati hibák) és naplózza a hibákat.
    • Ellenőrzi a HTTP státuszkódokat (IsSuccessStatusCode).
  • Teljesítményoptimalizálás:
    • Újrahasználja az HttpClient-t (ajánlott eljárás a TCP port kimerülés elkerüléséhez).
    • Konfigurálható keep-alive valós forgatókönyvek szimulálásához.

4. Példa használati eset

Egy SMS API tesztelése a http://localhost:8080/sms címen 1000 összes kéréssel (50 párhuzamos, keep-alive engedélyezve):

Program http://localhost:8080/sms 1000 50 true

Kimenet:

Test completed!
Total time: 12.34 seconds
Completed requests: 1000
Successful requests: 980
Failed requests: 20
Requests per second: 81.04

5. Miért fontos ez

  • Teljesítménymérés: Azonosítja az API szűk keresztmetszeteit (pl. szerver korlátok, hálózati késés).
  • Regressziós tesztelés: Biztosítja, hogy a teljesítmény ne romoljon frissítések után.
  • Kapacitástervezés: Meghatározza a szolgáltatás által kezelhető maximális terhelést.

6. Lehetséges fejlesztések

  • Újrapróbálkozási logika átmeneti hibákhoz.
  • Támogatás hitelesítéshez (OAuth/API kulcsok).
  • Eredmények exportálása CSV/JSON formátumba elemzéshez.

Ez az eszköz ideális fejlesztők és DevOps csapatok számára, akik az SMS átjáró teljesítményét ellenőrzik üzembe helyezés előtt.

Összegzés

A REST SMS szolgáltatásokhoz készült HTTP sebességteszt egy robusztus, könnyen használható megoldást kínál az SMS API végpontok teljesítményének és megbízhatóságának mérésére. Valósághű forgalom szimulálásával, konfigurálható párhuzamossággal, véletlenszerű üzenetgenerálással és részletes teljesítménymetrikákkal ez az eszköz segít a fejlesztőknek és QA csapatoknak azonosítani a szűk keresztmetszeteket, ellenőrizni a skálázhatóságot és optimalizálni az API válaszidejét. Legyen szó új telepítés terheléses teszteléséről vagy meglévő SMS átjáró auditálásáról, a mellékelt C# forráskód rugalmasságot biztosít testreszabáshoz, míg az előre összeállított végrehajtható fájl gyors, használható eredményeket nyújt. Töltsd le az eszközt még ma, hogy biztosítsd SMS szolgáltatásod megfelelő teljesítményét terhelés alatt – és zökkenőmentes élményt nyújts a végfelhasználóknak.

More information