Dela via

Push-arkitekturvägledning för företag

  • Artikel

Företag går i dag gradvis mot att skapa mobila program för antingen sina slutanvändare (externa) eller för de anställda (interna). De har befintliga serverdelssystem på plats, oavsett om det är stordatorer eller vissa LoB-program, som måste integreras i arkitekturen för mobilprogram. Den här guiden beskriver hur du bäst gör den här integreringen och rekommenderar en möjlig lösning på vanliga scenarier.

Ett vanligt krav är att skicka push-meddelanden till användarna via deras mobilprogram när en händelse av intresse inträffar i serverdelssystemen. Till exempel vill en bankkund som har bankens bankapp på en i Telefon meddelas när en debet görs över ett visst belopp från kontot eller ett intranätscenario där en anställd från ekonomiavdelningen som har en app för budgetgodkännande på en Windows-Telefon vill meddelas när godkännandebegäran tas emot.

Det är troligt att bearbetningen av bankkontot eller godkännandet görs i något serverdelssystem, vilket måste initiera en push-överföring till användaren. Det kan finnas flera sådana serverdelssystem, som alla måste skapa samma typ av logik för att push-överföra när en händelse utlöser ett meddelande. Komplexiteten här är att integrera flera serverdelssystem tillsammans med ett enda push-system där slutanvändarna kan ha prenumererat på olika meddelanden och det kan till och med finnas flera mobila program. Till exempel intranätsmobilappar där ett mobilprogram kanske vill ta emot meddelanden från flera sådana serverdelssystem. Serverdelssystemen vet inte eller behöver känna till push-semantik/teknik så en vanlig lösning här traditionellt har varit att införa en komponent, som avsöker serverdelssystemen efter händelser av intresse och ansvarar för att skicka push-meddelanden till klienten.

En bättre lösning är att använda Azure Service Bus – ämnes-/prenumerationsmodell, vilket minskar komplexiteten samtidigt som lösningen blir skalbar.

Här är lösningens allmänna arkitektur (generaliserad med flera mobilappar men lika tillämpligt när det bara finns en mobilapp)

Arkitektur

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

Den viktigaste delen i det här arkitekturdiagrammet är Azure Service Bus, som tillhandahåller en programmeringsmodell för ämnen/prenumerationer (mer information finns i Service Bus Pub/Sub-programmering). Mottagaren, som i det här fallet är mobilens serverdel (vanligtvis Azure Mobile Service, som initierar en push-överföring till mobilapparna) tar inte emot meddelanden direkt från serverdelssystemen, utan i stället ett mellanliggande abstraktionslager som tillhandahålls av Azure Service Bus, vilket gör det möjligt för mobil serverdel att ta emot meddelanden från ett eller flera serverdelssystem. Ett Service Bus-ämne måste skapas för vart och ett av serverdelssystemen, till exempel Konto, HR, Ekonomi, vilket i princip är "ämnen" av intresse, som initierar meddelanden som ska skickas som push-meddelanden. Serverdelssystemen skickar meddelanden till dessa ämnen. En mobil serverdel kan prenumerera på ett eller flera sådana ämnen genom att skapa en Service Bus-prenumeration. Den berättigar den mobila serverdelen att ta emot ett meddelande från motsvarande serverdelssystem. Mobil serverdelen fortsätter att lyssna efter meddelanden i sina prenumerationer och så snart ett meddelande kommer tillbaka vänder det tillbaka och skickar det som ett meddelande till sin meddelandehubb. Meddelandehubbar levererar sedan meddelandet till mobilappen. Här är listan över viktiga komponenter:

  1. Serverdelssystem (LoB/äldre system)
    • Skapar Service Bus-ämne
    • Skickar meddelande
  2. Mobil serverdel
    • Skapar tjänstprenumeration
    • Tar emot meddelande (från serverdelssystemet)
    • Skickar meddelanden till klienter (via Azure Notification Hub)
  3. Mobilprogram
    • Tar emot och visar meddelande

Förmåner

  1. Avkopplingen mellan mottagaren (mobilappen/tjänsten via Notification Hub) och avsändaren (serverdelssystem) gör det möjligt att integrera ytterligare serverdelssystem med minimal ändring.
  2. Det gör också att scenariot med flera mobilappar kan ta emot händelser från ett eller flera serverdelssystem.

Exempel

Förutsättningar

Slutför följande självstudier för att bekanta dig med begreppen samt vanliga steg för att skapa och konfigurera:

  1. Service Bus Pub/Underprogrammering – Den här självstudien beskriver hur du arbetar med Service Bus-ämnen/-prenumerationer, hur du skapar ett namnområde som innehåller ämnen/prenumerationer, hur du skickar och tar emot meddelanden från dem.
  2. Notification Hubs – Självstudie om Windows Universal – Den här självstudien beskriver hur du konfigurerar en Windows Store-app och använder Notification Hubs för att registrera och sedan ta emot meddelanden.

Exempelkod

Den fullständiga exempelkoden är tillgänglig i Notification Hub-exempel. Den är uppdelad i tre komponenter:

  1. EnterprisePushBackendSystem

    a. Det här projektet använder NuGet-paketet Azure.Messaging.ServiceBus och baseras på Service Bus Pub/Sub-programmering.

    b. Det här programmet är en enkel C#-konsolapp för att simulera ett LoB-system som initierar meddelandet som ska levereras till mobilappen.

    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 används för att skapa Service Bus-ämnet.

    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 används för att skicka meddelanden till det här Service Bus-ämnet. Den här koden skickar helt enkelt en uppsättning slumpmässiga meddelanden till ämnet med jämna mellanrum i exemplet. Normalt finns det ett serverdelssystem som skickar meddelanden när en händelse inträffar.

    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. Det här projektet använder Paketen Azure.Messaging.ServiceBus och Microsoft.Web.WebJobs.Publish NuGet och baseras på Service Bus Pub/Sub-programmering.

    b. Följande konsolapp körs som ett Azure-webbjobb eftersom den måste köras kontinuerligt för att lyssna efter meddelanden från LoB/serverdelssystemen. Det här programmet är en del av din mobila serverdel.

    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 används för att skapa en Service Bus-prenumeration för ämnet där serverdelssystemet skickar meddelanden. Beroende på affärsscenariot skapar den här komponenten en eller flera prenumerationer på motsvarande ämnen (till exempel kan vissa ta emot meddelanden från HR-system, vissa från Ekonomisystem och så vidare)

    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 används för att läsa meddelandet från ämnet med hjälp av dess prenumeration och om läsningen lyckas skapar du ett meddelande (i exempelscenariot ett windows-inbyggt popup-meddelande) som ska skickas till mobilprogrammet med hjälp av 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. Om du vill publicera den här appen som ett webbjobb högerklickar du på lösningen i Visual Studio och väljer Publicera som webbjobb

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

    f. Välj din publiceringsprofil och skapa en ny Azure WebSite om den inte redan finns, som är värd för det här webbjobbet och när du har webbwebbplatsen sedan Publicera.

    Screenshot showing the workflow to create a site on Azure.

    g. Konfigurera jobbet till "Kör kontinuerligt" så att du bör se något som liknar följande när du loggar in på Azure-portalen :

    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. Det här programmet är ett Windows Store-program som tar emot popup-meddelanden från webbjobbet som körs som en del av din mobila serverdel och visar det. Den här koden baseras på Notification Hubs – Windows Universal-självstudie.

    b. Kontrollera att programmet är aktiverat för att ta emot popup-meddelanden.

    c. Kontrollera att följande Notification Hubs-registreringskod anropas vid appstarten (efter att värdena och DefaultListenSharedAccessSignature har ersattsHubName:

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

Köra exemplet

  1. Kontrollera att webbjobbet körs korrekt och schemalagt att köras kontinuerligt.

  2. Kör EnterprisePushMobileApp, som startar Windows Store-appen.

  3. Kör konsolprogrammet EnterprisePushBackendSystem, som simulerar LoB-serverdelen och börjar skicka meddelanden och du bör se popup-meddelanden som visas som följande bild:

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

  4. Meddelandena skickades ursprungligen till Service Bus-ämnen, som övervakades av Service Bus-prenumerationer i ditt webbjobb. När ett meddelande togs emot skapades ett meddelande och skickades till mobilappen. Du kan titta igenom webbjobbsloggarna för att bekräfta bearbetningen när du går till länken Loggar i Azure-portalen för ditt webbjobb:

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