Hulp voor architectuur via pushmeldingen van het bedrijf

Ondernemingen maken tegenwoordig geleidelijk mobiele toepassingen voor hun eindgebruikers (extern) of voor de werknemers (intern). Ze hebben bestaande back-endsystemen, of het nu mainframes of sommige LoB-toepassingen zijn, die moeten worden geïntegreerd in de architectuur van de mobiele toepassing. In deze handleiding wordt be gesproken over hoe u deze integratie het beste kunt doen om een mogelijke oplossing voor veelvoorkomende scenario's aan te bevelen.

Een veelvoorwaarde is het verzenden van pushmeldingen naar de gebruikers via hun mobiele toepassing wanneer er een gebeurtenis plaatsvindt in de back-endsystemen. Een bankklant die bijvoorbeeld de bank-app van de bank op een iPhone heeft, wil een melding ontvangen wanneer er een debitering wordt gedaan boven een bepaald bedrag van de rekening of een intranetscenario waarbij een werknemer van de financiële afdeling die een app voor budgetgoedkeuring heeft op een Windows Phone een melding wil ontvangen wanneer de goedkeuringsaanvraag wordt ontvangen.

De bankaccount of goedkeuringsverwerking wordt waarschijnlijk uitgevoerd in een back-endsysteem, dat een push naar de gebruiker moet initiëren. Er kunnen meerdere van dergelijke back-endsystemen zijn, die allemaal hetzelfde soort logica moeten bouwen om te pushen wanneer een gebeurtenis een melding activeert. De complexiteit ligt hier in het integreren van verschillende back-endsystemen in één pushsysteem waarbij de eindgebruikers zich mogelijk hebben geabonneerd op verschillende meldingen en er zelfs meerdere mobiele toepassingen kunnen zijn. Bijvoorbeeld mobiele intranet-apps waarbij één mobiele toepassing meldingen wil ontvangen van meerdere dergelijke back-upsystemen. De back-endsystemen weten geen push-semantiek/-technologie of hoeven deze niet te kennen. Daarom is een veelgebruikte oplossing hier traditioneel het introduceren van een onderdeel, dat de back-endsystemen op belangrijke gebeurtenissen peilt en verantwoordelijk is voor het verzenden van de pushberichten naar de client.

Een betere oplossing is het gebruik van Azure Service Bus- onderwerp-/abonnementsmodel, wat de complexiteit vermindert en de oplossing schaalbaar maakt.

Hier is de algemene architectuur van de oplossing (ge generaliseerd met meerdere mobiele apps, maar even toepasselijk wanneer er slechts één mobiele app is)

Architectuur

Diagram van de bedrijfsarchitectuur met de stroom door gebeurtenissen, abonnementen en pushberichten.

Het belangrijkste deel van dit architectuurdiagram is Azure Service Bus, dat een programmeermodel voor onderwerpen/abonnementen biedt (meer informatie over het Service Bus [Pub/Sub programming).] De ontvanger, in dit geval de mobiele back-end (meestal [Azure Mobile Service,]die een push naar de mobiele apps initieert), ontvangt geen berichten rechtstreeks van de back-endsystemen, maar in plaats daarvan een tussenliggende abstractielaag van [Azure Service Bus,]waarmee mobiele back-endberichten kunnen ontvangen van een of meer back-endsystemen. Er moet Service Bus onderwerp worden gemaakt voor elk van de back-endsystemen, bijvoorbeeld Account, HR, Finance. Dit zijn in feite 'onderwerpen' die berichten initiëren die als pushmelding moeten worden verzonden. De back-endsystemen verzenden berichten naar deze onderwerpen. Een Mobile Backend kan zich abonneren op een of meer van dergelijke onderwerpen door een Service Bus maken. Het geeft de mobiele back-up de tijd om een melding te ontvangen van het bijbehorende back-endsysteem. De mobiele back-up blijft luisteren naar berichten in hun abonnementen. Zodra er een bericht binnenkomt, wordt het terug draait en als een melding verzonden naar de Notification Hub. Notification Hubs leveren het bericht uiteindelijk aan de mobiele app. Hier is de lijst met belangrijke onderdelen:

  1. Back-endsystemen (LoB-/verouderde systemen)
    • Maakt Service Bus onderwerp
    • Verzendt een bericht
  2. Mobiele back-end
    • Hiermee maakt u een serviceabonnement
    • Bericht ontvangen (van back-endsysteem)
    • Verzendt een melding naar clients (via Azure Notification Hub)
  3. Mobiele toepassing
    • Ontvangt een melding en geeft deze weer

Voordelen

  1. Door de ontkoppeling tussen de ontvanger (mobiele app/service via Notification Hub) en de afzender (back-endsystemen) kunnen extra back-upsystemen worden geïntegreerd met minimale wijziging.
  2. Het maakt ook het scenario waarin meerdere mobiele apps gebeurtenissen kunnen ontvangen van een of meer back-endsystemen.

Voorbeeld

Vereisten

Voltooi de volgende zelfstudies om vertrouwd te raken met de concepten en algemene configuratiestappen & maken:

  1. [Service Bus Pub/Sub programming:] in deze zelfstudie wordt uitgelegd hoe u met Service Bus-onderwerpen/-abonnementen werkt, hoe u een naamruimte maakt die onderwerpen/abonnementen bevat en hoe u berichten & ontvangt.
  2. [Notification Hubs - Windows Universal-zelfstudie:] in deze zelfstudie wordt uitgelegd hoe u een Windows Store-app in kunt stellen en hoe u Notification Hubs gebruikt om u te registreren en vervolgens meldingen te ontvangen.

Voorbeeldcode

De volledige voorbeeldcode is beschikbaar op [Notification Hub Samples]. Deze is opgesplitst in drie onderdelen:

  1. EnterprisePushBackendSystem

    a. Dit project maakt gebruik van het Azure.Messaging.ServiceBus NuGet-pakket en is gebaseerd [op Service Bus Pub/Sub programming.]

    b. Deze toepassing is een eenvoudige C#-console-app voor het simuleren van een LoB-systeem, waarmee het bericht wordt geïnitieerd dat aan de mobiele app wordt geleverd.

    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. CreateTopicAsyncwordt gebruikt om het Service Bus maken.

    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. SendMessageAsyncwordt gebruikt om de berichten naar dit onderwerp Service Bus verzenden. Met deze code wordt periodiek een reeks willekeurige berichten naar het onderwerp verzonden met het doel van het voorbeeld. Normaal gesproken is er een back-endsysteem dat berichten verzendt wanneer er een gebeurtenis plaatsvindt.

    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. Dit project maakt gebruik van de NuGet-pakketten Azure.Messaging.ServiceBus en Microsoft.Web.WebJobs.Publish en is gebaseerd [op Service Bus Pub/Sub programming.]

    b. De volgende console-app wordt uitgevoerd als [een Azure-webjob] omdat deze continu moet worden uitgevoerd om te luisteren naar berichten van de LoB-/back-endsystemen. Deze toepassing maakt deel uit van uw mobiele back-end.

    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. CreateSubscriptionAsyncwordt gebruikt om een Service Bus maken voor het onderwerp waar het back-endsysteem berichten verzendt. Afhankelijk van het bedrijfsscenario maakt dit onderdeel een of meer abonnementen op de bijbehorende onderwerpen (sommige ontvangen bijvoorbeeld berichten van het HR-systeem, een aantal van het financiële systeem, bijvoorbeeld)

    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. ReceiveMessageAndSendNotificationAsyncwordt gebruikt om het bericht uit het onderwerp te lezen met behulp van het abonnement. Als het lezen is geslaagd, maakt u een melding (in het voorbeeldscenario een systeemeigen pop-upmelding van Windows) die naar de mobiele toepassing wordt verzonden met behulp van Azure Notification Hubs.

    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. Als u deze app wilt publiceren als een webjob, klikt u met de rechtermuisknop op de oplossing in Visual Studio selecteert u Publiceren als webjob

    Schermopname van de opties voor klikken met de rechtermuisknop die worden weergegeven met Publiceren als Azure-webjob rood omschreven.

    f. Selecteer uw publicatieprofiel en maak een nieuwe Azure-website als deze nog niet bestaat, die als host voor deze webjob wordt gebruikt en als u de WebSite hebt en vervolgens Publiceren.

    Schermopname van de werkstroom voor het maken van een site in Azure.

    g. Configureer de taak zodanig dat deze continu wordt uitgevoerd, zodat wanneer u zich aanmeldt bij de [Azure Portal] u iets als het volgende ziet:

    Schermopname van Azure Portal met de enterprise push back-end-webjobs weergegeven en de waarden naam, planning en logboeken rood.

  3. EnterprisePushMobileApp

    a. Deze toepassing is een Windows Store-toepassing die pop-upmeldingen ontvangt van de webjob die wordt uitgevoerd als onderdeel van uw mobiele back-up en deze we weergeven. Deze code is gebaseerd op Notification Hubs - Windows Universal-zelfstudie.

    b. Zorg ervoor dat uw toepassing is ingeschakeld voor het ontvangen van pop-upmeldingen.

    c. Zorg ervoor dat de volgende Notification Hubs wordt aangeroepen bij het starten van de app (nadat u de waarden en HubName hebt DefaultListenSharedAccessSignature vervangen:

    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();
    }
}

Het voorbeeld uitvoeren

  1. Zorg ervoor dat uw webjob wordt uitgevoerd en is gepland om continu te worden uitgevoerd.

  2. Voer de EnterprisePushMobileApp uit, waarmee de Windows Store-app wordt gestart.

  3. Voer de consoletoepassing EnterprisePushBackendSystem uit, die de LoB-back-up simuleert en begint met het verzenden van berichten. U ziet pop-upmeldingen zoals in de volgende afbeelding:

    Schermopname van een console met de Enterprise Push Backend System-app en het bericht dat door de app wordt verzonden.

  4. De berichten zijn oorspronkelijk verzonden Service Bus onderwerpen, die werden bewaakt door Service Bus-abonnementen in uw web job. Zodra een bericht is ontvangen, is er een melding gemaakt en verzonden naar de mobiele app. U kunt de webjoblogboeken bekijken om de verwerking te bevestigen wanneer u naar de koppeling Logboeken [in] Azure Portal voor uw webjob gaat:

    Schermopname van het dialoogvenster Details van continue webjob met het bericht dat in rood wordt verzonden.