Útmutató a vállalati leküldési architektúrákhoz

  • Cikk

A vállalatok ma fokozatosan haladnak a mobilalkalmazások létrehozása felé a végfelhasználók (külső) vagy az alkalmazottak (belső) számára. Meglévő háttérrendszerekkel rendelkeznek, legyen szó főszámítógépekről vagy néhány LoB-alkalmazásról, amelyeket integrálni kell a mobilalkalmazás-architektúrába. Ez az útmutató bemutatja, hogyan lehet a legjobban elvégezni ezt az integrációt, és hogyan lehet megoldást javasolni a gyakori forgatókönyvekre.

Gyakori követelmény a leküldéses értesítés küldése a felhasználók számára a mobilalkalmazáson keresztül, ha a háttérrendszerekben fontos esemény történik. Például egy banki ügyfél, aki rendelkezik a bank banki alkalmazásával egy i Telefon szeretne értesítést kapni, ha egy terhelés egy bizonyos összeg felett történik a fiókból vagy egy intranetes forgatókönyvből, ahol a pénzügyi részleg egyik alkalmazottja, aki egy Windows Phone-telefon költségvetés-jóváhagyási alkalmazással rendelkezik, értesítést szeretne kapni a jóváhagyási kérelem beérkezésekor.

A bankszámla vagy jóváhagyás feldolgozása valószínűleg valamilyen háttérrendszerben történik, amelynek leküldést kell kezdeményeznie a felhasználónak. Több ilyen háttérrendszer is lehet, amelyeknek ugyanazt a logikát kell létrehozniuk, amelyet le kell küldeni, amikor egy esemény elindít egy értesítést. Ennek összetettsége abban rejlik, hogy több háttérrendszert integrál egyetlen leküldéses rendszerrel, ahol a végfelhasználók különböző értesítésekre iratkoztak fel, és akár több mobilalkalmazás is lehet. Például az intranetes mobilalkalmazások, amelyekben egy mobilalkalmazás több ilyen háttérrendszertől szeretne értesítéseket kapni. A háttérrendszerek nem ismerik vagy nem kell ismerni a leküldéses szemantikát/technológiát, ezért itt hagyományosan egy olyan összetevő bevezetése volt a közös megoldás, amely lekérdezi a háttérrendszereket minden érdekes eseményhez, és felelős a leküldéses üzenetek ügyfélnek való küldéséért.

Jobb megoldás az Azure Service Bus - Topic/Subscription modell használata, amely csökkenti a bonyolultságot, miközben a megoldás méretezhetővé válik.

Itt található a megoldás általános architektúrája (több mobilalkalmazással általánosítva, de ugyanúgy alkalmazható, ha csak egy mobilalkalmazás van)

Felépítés

Diagram of the enterprise architecture showing the flow through Events, Subscriptions, and Push Messages.

Az architekturális diagram fő eleme az Azure Service Bus, amely egy témakörök/előfizetések programozási modelljét tartalmazza (erről bővebben a Service Bus Pub/Alprogramozás oldalon olvashat). A fogadó, amely ebben az esetben a Mobile háttérrendszer (általában az Azure Mobile Service, amely leküldést kezdeményez a mobilalkalmazásokba) nem közvetlenül a háttérrendszerekből fogad üzeneteket, hanem az Azure Service Bus által biztosított köztes absztrakciós réteg, amely lehetővé teszi, hogy a mobil háttérrendszer üzeneteket fogadjon egy vagy több háttérrendszerből. Létre kell hozni egy Service Bus-témakört minden háttérrendszerhez, például fiókhoz, HR-hez, pénzügyhez, amely alapvetően "érdekes témakörök", és amely leküldéses értesítésként küldi el az üzeneteket. A háttérrendszerek üzeneteket küldenek ezekhez a témakörökhöz. A Mobile Backend egy Service Bus-előfizetés létrehozásával előfizethet egy vagy több ilyen témakörre. Ez feljogosítja a mobil háttérrendszert, hogy értesítést kapjon a megfelelő háttérrendszertől. A mobil háttérrendszer továbbra is figyeli az előfizetéseikben lévő üzeneteket, és amint megérkezik egy üzenet, visszafordul, és értesítést küld az értesítési központnak. Az értesítési központok végül kézbesítik az üzenetet a mobilalkalmazásnak. Íme a legfontosabb összetevők listája:

  1. Háttérrendszerek (LoB/Örökölt rendszerek)
    • Service Bus-témakör létrehozása
    • Üzenet küldése
  2. Mobil háttérrendszer
    • Szolgáltatás-előfizetés létrehozása
    • Üzenet fogadása (háttérrendszerből)
    • Értesítés küldése az ügyfeleknek (az Azure Notification Hubon keresztül)
  3. Mobilalkalmazás
    • Értesítés fogadása és megjelenítése

Előnyök

  1. A fogadó (mobilalkalmazás/szolgáltatás a Notification Hubon keresztül) és a küldő (háttérrendszerek) közötti leválasztással további háttérrendszerek integrálhatók minimális módosítással.
  2. Azt is lehetővé teszi, hogy több mobilalkalmazás is fogadhasson eseményeket egy vagy több háttérrendszerből.

Minta

Előfeltételek

Végezze el az alábbi oktatóanyagokat a fogalmak és a gyakori létrehozási és konfigurációs lépések megismeréséhez:

  1. Service Bus Pub/Alprogramozás – Ez az oktatóanyag bemutatja a Service Bus-témakörök/előfizetések használatának részleteit, a témaköröket/előfizetéseket tartalmazó névtér létrehozását, az üzenetek küldését és fogadását.
  2. Notification Hubs – Univerzális Windows-oktatóanyag – Ez az oktatóanyag bemutatja, hogyan állíthat be Windows Áruházbeli alkalmazást, és hogyan használhatja a Notification Hubsot az értesítések regisztrálására és fogadására.

Mintakód

A teljes mintakód elérhető a Notification Hub-mintákban. Három összetevőre van felosztva:

  1. EnterprisePushBackendSystem

    a. Ez a projekt az Azure.Messaging.ServiceBus NuGet csomagot használja, és a Service Bus Pub/Alprogramozáson alapul.

    b. Ez az alkalmazás egy egyszerű C#-konzolalkalmazás egy LoB-rendszer szimulálásához, amely elindítja az üzenetet a mobilalkalmazásba való kézbesítéshez.

    static async Task Main(string[] args)
{
    string connectionString =
        ConfigurationManager.AppSettings.Get("Azure.ServiceBus.ConnectionString");

    // Create the topic
    await CreateTopicAsync(connectionString);

    // Send message
    await SendMessageAsync(connectionString);
}

    c. CreateTopicAsync a Service Bus-témakör létrehozásához használható.

    public static async Task CreateTopicAsync(string connectionString)
{
    // Create the topic if it does not exist already
    ServiceBusAdministrationClient client = new ServiceBusAdministrationClient(connectionString);

    if (!await client.TopicExistsAsync(topicName))
    {
        await client.CreateTopicAsync(topicName);
    }
}

    d. SendMessageAsync az üzeneteket erre a Service Bus-témakörre küldi. Ez a kód egyszerűen véletlenszerű üzeneteket küld a témakörnek rendszeres időközönként a minta céljából. Általában van egy háttérrendszer, amely üzeneteket küld egy esemény bekövetkezésekor.

    public static sync Task SendMessageAsync(string connectionString)
{
    await using var client = new ServiceBusClient(connectionString);
    ServiceBusSender sender = client.CreateSender(topicName);

    // Sends random messages every 10 seconds to the topic
    string[] messages =
    {
        "Employee Id '{0}' has joined.",
        "Employee Id '{0}' has left.",
        "Employee Id '{0}' has switched to a different team."
    };

    while (true)
    {
        Random rnd = new Random();
        string employeeId = rnd.Next(10000, 99999).ToString();
        string notification = String.Format(messages[rnd.Next(0,messages.Length)], employeeId);

        // Send Notification
        ServiceBusMessage message = new ServiceBusMessage(notification);
        await sender.SendMessageAsync(message);

        Console.WriteLine("{0} Message sent - '{1}'", DateTime.Now, notification);

        System.Threading.Thread.Sleep(new TimeSpan(0, 0, 10));
    }
}

  2. ReceiveAndSendNotification

    a. Ez a projekt az Azure.Messaging.ServiceBus és a Microsoft.Web.WebJobs.Publish NuGet-csomagokat használja, és a Service Bus Pub/Alprogramozáson alapul.

    b. A következő konzolalkalmazás Azure WebJob-feladatként fut, mivel folyamatosan kell futnia a LoB/háttérrendszerek üzeneteinek figyeléséhez. Ez az alkalmazás a Mobile háttérrendszer része.

    static async Task Main(string[] args)
{
    string connectionString =
             ConfigurationManager.AppSettings.Get("Azure.ServiceBus.ConnectionString");

    // Create the subscription that receives messages
    await CreateSubscriptionAsync(connectionString);

    // Receive message
    await ReceiveMessageAndSendNotificationAsync(connectionString);
}

    c. CreateSubscriptionAsync Service Bus-előfizetés létrehozására szolgál ahhoz a témakörhöz, amelyben a háttérrendszer üzeneteket küld. Az üzleti forgatókönyvtől függően ez az összetevő egy vagy több előfizetést hoz létre a megfelelő témakörökhöz (például egyeseket a HR-rendszertől, néhányat a Pénzügyi rendszertől stb.)

    static async Task CreateSubscriptionAsync(string connectionString)
{
    // Create the subscription if it does not exist already
    ServiceBusAdministrationClient client = new ServiceBusAdministrationClient(connectionString);

    if (!await client.SubscriptionExistsAsync(topicName, subscriptionName))
    {
        await client.CreateSubscriptionAsync(topicName, subscriptionName);
    }
}

    d. ReceiveMessageAndSendNotificationAsync a témakör üzenetének olvasására szolgál az előfizetésével, és ha az olvasás sikeres, akkor küldjön egy értesítést (a mintaforgatókönyvben egy natív bejelentési értesítést a Windowsról), amelyet az Azure Notification Hubs használatával küld el a mobilalkalmazásnak.

    static async Task ReceiveMessageAndSendNotificationAsync(string connectionString)
{
    // Initialize the Notification Hub
    string hubConnectionString = ConfigurationManager.AppSettings.Get
            ("Microsoft.NotificationHub.ConnectionString");
    hub = NotificationHubClient.CreateClientFromConnectionString
            (hubConnectionString, "enterprisepushservicehub");

    ServiceBusClient Client = new ServiceBusClient(connectionString);
    ServiceBusReceiver receiver = Client.CreateReceiver(topicName, subscriptionName);

    // Continuously process messages received from the subscription
    while (true)
    {
        ServiceBusReceivedMessage message = await receiver.ReceiveMessageAsync();
        var toastMessage = @"<toast><visual><binding template=""ToastText01""><text id=""1"">{messagepayload}</text></binding></visual></toast>";

        if (message != null)
        {
            try
            {
                Console.WriteLine(message.MessageId);
                Console.WriteLine(message.SequenceNumber);
                string messageBody = message.Body.ToString();
                Console.WriteLine("Body: " + messageBody + "\n");

                toastMessage = toastMessage.Replace("{messagepayload}", messageBody);
                SendNotificationAsync(toastMessage);

                // Remove message from subscription
                await receiver.CompleteMessageAsync(message);
            }
            catch (Exception)
            {
                // Indicate a problem, unlock message in subscription
                await receiver.AbandonMessageAsync(message);
            }
        }
    }
}
static async void SendNotificationAsync(string message)
{
    await hub.SendWindowsNativeNotificationAsync(message);
}

    e. Az alkalmazás WebJobként való közzétételéhez kattintson a jobb gombbal a Visual Studióban a megoldásra, és válassza a Közzététel WebJobként lehetőséget

    Screenshot of the right-click options being displayed with Publish as Azure WebJob outlined in red.

    f. Válassza ki a közzétételi profilt, és hozzon létre egy új Azure WebSite-webhelyet, ha még nem létezik, amely üzemelteti ezt a WebJob-feladatot, és ha már rendelkezik a WebSite-tal, majd tegye közzé.

    Screenshot showing the workflow to create a site on Azure.

    : Konfigurálja a feladatot "Folyamatos futtatás" értékre, hogy amikor bejelentkezik az Azure Portalra , az alábbihoz hasonlót kell látnia:

    Screenshot of the Azure Portal with the enterprise push backend webjobs displayed and the Name, Schedule, and Logs values outlined in red.

  3. EnterprisePushMobileApp

    a. Ez az alkalmazás egy Windows Áruházbeli alkalmazás, amely bejelentési értesítéseket kap a Mobile-háttérrendszer részeként futó WebJobtól, és megjeleníti azt. Ez a kód a Notification Hubs - Univerzális Windows-oktatóanyagon alapul.

    b. Győződjön meg arról, hogy az alkalmazás engedélyezve van a bejelentési értesítések fogadásához.

    c. Győződjön meg arról, hogy a következő Notification Hubs regisztrációs kód van meghívva az alkalmazás indításakor (az és DefaultListenSharedAccessSignature az HubName értékek cseréje után:

    private async void InitNotificationsAsync()
{
    var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

    var hub = new NotificationHub("[HubName]", "[DefaultListenSharedAccessSignature]");
    var result = await hub.RegisterNativeAsync(channel.Uri);

    // Displays the registration ID so you know it was successful
    if (result.RegistrationId != null)
    {
        var dialog = new MessageDialog("Registration successful: " + result.RegistrationId);
        dialog.Commands.Add(new UICommand("OK"));
        await dialog.ShowAsync();
    }
}

A minta futtatása

  1. Győződjön meg arról, hogy a WebJob sikeresen fut, és ütemezetten folyamatosan fut.

  2. Futtassa az EnterprisePushMobileApp alkalmazást, amely elindítja a Windows Áruházbeli alkalmazást.

  3. Futtassa az EnterprisePushBackendSystem konzolalkalmazást, amely szimulálja a LoB-háttérrendszert, és elkezd üzeneteket küldeni, és a bejelentési értesítéseknek az alábbi képhez hasonlóan kell megjelennie:

    Screenshot of a console running the Enterprise Push Backend System app and the message that is sent by the app.

  4. Az üzeneteket eredetileg Service Bus-témakörökbe küldték, amelyeket a Web Job Service Bus-előfizetései figyeltek. Az üzenet fogadása után létrejön egy értesítés, amelyet elküld a mobilalkalmazásnak. A WebJob-naplókban ellenőrizheti a feldolgozást, amikor a webes feladathoz tartozó Azure Portal Naplók hivatkozására lép:

    Screenshot of the Continuous WebJob Details dialog box with the message that is sent outlined in red.