Push-arkitekturvägledning för företag

Företag i dag går gradvis mot att skapa mobilprogram för antingen sina slutanvändare (externa) eller för de anställda (internt). De har befintliga backend-system på plats, till exempel stordatorer eller vissa LoB-program, som måste integreras i arkitekturen för mobila program. Den här guiden handlar om 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 backend-systemen. Till exempel vill en bankkund som har bankappen på en iPhone få ett meddelande när en debet görs över ett visst belopp från kontot eller ett intranätscenario där en medarbetare från ekonomiavdelningen som har en app för budgetgodkännande på en Windows Phone vill få ett meddelande när begäran om godkännande tas emot.

Bearbetningen av bankkonton eller godkännanden görs troligen i ett backend-system, som måste initiera en push-fil till användaren. Det kan finnas flera sådana backend-system, som alla måste skapa samma typ av logik som ska skickas när en händelse utlöser ett meddelande. Komplexiteten här ligger i att integrera flera backend-system tillsammans med ett enda push-system där slutanvändarna kan ha prenumererat på olika meddelanden och det kan till och med finnas flera mobilprogram. Det kan till exempel vara intranätsmobilappar där ett mobilprogram kan vilja ta emot meddelanden från flera sådana backend-system. Backend-systemen vet inte eller behöver känna till push-semantik/teknik, så en vanlig lösning här har traditionellt varit att introducera en komponent som avsöker backend-systemen 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 den allmänna arkitekturen i lösningen (generaliserad med flera mobilappar men lika tillämplig när det bara finns en mobilapp)

Arkitektur

Diagram över företagsarkitekturen som visar flödet genom händelser, prenumerationer och push-meddelanden.

Det viktigaste i det här arkitekturdiagrammet är Azure Service Bus, som innehåller en programmeringsmodell för ämnen/prenumerationer (mer information finns i [Service Bus Pub/Sub programming]). Mottagaren, som i det här fallet är den mobila backend-enheten (vanligtvis Azure Mobile Service, som initierar en push-push till mobilapparna) tar inte emot meddelanden direkt från backend-systemen, utan i stället ett mellanliggande abstraktionslager som tillhandahålls av Azure [Service Bus], vilket gör att den mobila backend-enheten kan ta emot meddelanden från ett eller flera backend-system. Ett Service Bus ämne måste skapas för varje backend-system, till exempel Konto, HR, Ekonomi, vilket i princip är "intressanta ämnen" som initierar att meddelanden skickas som push-meddelanden. Backend-systemen skickar meddelanden till dessa ämnen. En mobil backend kan prenumerera på ett eller flera sådana ämnen genom att skapa en Service Bus prenumeration. Den berättigar den mobila backend att ta emot ett meddelande från motsvarande backend-system. Mobil backend fortsätter att lyssna efter meddelanden på sina prenumerationer och när ett meddelande anländer, vänder den tillbaka och skickar den som ett meddelande till sin meddelandehubb. Notification Hubs levererar sedan slutligen meddelandet till mobilappen. Här är listan över viktiga komponenter:

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

Fördelar

  1. Frikopplingen mellan mottagaren (mobilapp/tjänst via Notification Hub) och avsändaren (backend-system) gör att ytterligare backend-system kan integreras med minimal förändring.
  2. Det gör också att flera mobilappar kan ta emot händelser från ett eller flera backend-system.

Exempel

Förutsättningar

Slutför följande självstudier för att bekanta dig med begreppen samt vanliga & konfigurationsstegen:

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

Exempelkod

Den fullständiga exempelkoden finns på [Notification Hub Samples]. Den är uppdelad i tre komponenter:

  1. EnterprisePushBackendSystem

    a. Det här projektet använder NuGet-paketet Azure.Messaging.ServiceBus och baseras 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. CreateTopicAsyncanvä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. SendMessageAsyncanvänds för att skicka meddelanden till det här Service Bus ämne. Den här koden skickar helt enkelt en uppsättning slumpmässiga meddelanden till ämnet med jämna mellanrum för exemplets syfte. Vanligtvis finns det ett backend-system 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 NuGet-paketen Azure.Messaging.ServiceBus och Microsoft.Web.WebJobs.Publish 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/backend-systemen. Det här programmet är en del av din mobila backend.

    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. CreateSubscriptionAsyncanvänds för att skapa Service Bus prenumeration för det ämne där backend-systemet skickar meddelanden. Beroende på affärsscenario skapar den här komponenten en eller flera prenumerationer på motsvarande ämnen (vissa kan till exempel ta emot meddelanden från HR-systemet, vissa från ekonomisystemet 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. ReceiveMessageAndSendNotificationAsyncanvänds för att läsa meddelandet från ämnet med hjälp av prenumerationen 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. För att publicera den här appen som ett webbjobb högerklickar du på lösningen i Visual Studio väljer Publish as WebJob (Publicera som webbjobb)

    Skärmbild av alternativen för högerklickning som visas med Publicera som Azure WebJob i rött.

    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 websiten publicerar du.

    Skärmbild som visar arbetsflödet för att skapa en webbplats i Azure.

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

    Skärmbild av Azure-portalen med enterprise push-webbjobb för backend och värdena Namn, Schema och Loggar som beskrivs i rött.

  3. EnterprisePushMobileApp

    a. Det här programmet är Windows Store-program som tar emot popup-meddelanden från webbjobbet som körs som en del av din mobila backend och visar det. Den här koden baseras på [Notification Hubs – Windows Universal.]

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

    c. Kontrollera att följande Notification Hubs anropas vid appstarten (när du har ersatt värdena HubName DefaultListenSharedAccessSignature och :

    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 har schemalagts att köras kontinuerligt.

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

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

    Skärmbild av en konsol som kör appen Enterprise Push Backend System och meddelandet som skickas av appen.

  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 som skickades till mobilappen. Du kan titta igenom webjobloggarna för att bekräfta bearbetningen när du går till länken Loggar [i Azure Portal] för ditt webbjobb:

    Skärmbild av dialogrutan Information om kontinuerligt webbjobb med meddelandet som skickas i rött.