Liveaktualisierung

improve this page | report issue

Übersicht

Benutzersegmente sind Benutzergruppen, die Benutzer mit jeweils ähnlichen Eigenschaften enthalten. Ein allgemeines Beispiel für die Erstellung von Benutzersegmenten ist die geografische Segmentierung, bei der Benutzer ausgehend von der Geografie in Gruppen unterteilt werden. Ziel solcher Benutzersegmente ist es, den Wert für die Benutzer der einzelnen Segmente zu optimieren.

Mithilfe des Liveaktualisierungsfeatures der Mobile Foundation können auf einfache Weise verschiedene Konfigurationen für einzelne Benutzersegmente einer Anwendung definiert und bereitgestellt werden. In der MobileFirst Operations Console gibt es eine Komponente zum Definieren der Konfigurationsstruktur und der Konfigurationswerte für jedes Segment. Darüber hinaus gibt es ein Client-SDK (für native Android- und iOS-Anwendungen und für Cordova-Anwendungen), das die Konfiguration einliest.

Gängige Anwendungsfälle

Die Liveaktualisierung unterstützt das Definieren und Konsumieren von Segmentkonfigurationen und vereinfacht so segmentgerechte Anpassungen der Anwendung. Allgemeine Anwendungsfälle sind:

  • Release Trains und Feature Flipping
  • A/B-Tests
  • Kontextbasierte Anpassung der Anwendung (z. B. bei der geografischen Segmentierung)

Demonstration

Im folgenden Video wird das Feature für Liveaktualisierung demonstriert.

Fahren Sie mit folgenden Abschnitten fort:

Architektur für Liveaktualisierung

Die folgenden Systemkomponenten stellen zusammen die Funktionalität für Liveaktualisierungen bereit.

Architekturübersicht

  • Adapter für Liveaktualisierung: Dieser Adapter ermöglicht Folgendes:
  • Verwaltung von Anwendungsschema und Segmenten
  • Bereitstellung von Konfigurationen für Anwendungen
  • Segment-Resolver-Adapter: Dieser angepasste (und optionale) Adapter wird vom Entwickler implementiert. Der Adapter empfängt einen Anwendungskontext (z. B. einen Geräte- und Benutzerkontext mit angepassten Parametern) und gibt die ID eines Segments zurück, das mit dem Kontext korrespondiert.
  • Clientseitiges SDK: Das SDK für Liveaktualisierung wird verwendet, um Konfigurationselemente wie Funktionen und Eigenschaften von MobileFirst Server abzurufen und auf diese Elemente zuzugreifen.
  • MobileFirst Operations Console: In der Konsole werden der Adapter für Liveaktualisierung und die zugehörigen Einstellungen konfiguriert.
  • Konfigurationsservice: Dieser interne Service ermöglicht die Verwaltung der Konfiguration des Adapters für Liveaktualisierung.

Liveaktualisierung zu MobileFirst Server hinzufügen

Standardmäßig werden die Einstellungen für Liveaktualisierung in der MobileFirst Operations Console ausgeblendet. Zum Aktivieren der Einstellungen muss der Adapter für Liveaktualisierung implementiert werden.

  1. Öffnen Sie die MobileFirst Operations Console. Klicken Sie im Seitenleistennavigator auf Download-Center und dann auf das Register Tools.
  2. Laden Sie den Adapter für Liveaktualisierung herunter und implementieren Sie ihn.

Nach der Implementierung können Sie für jede registrierte Anwendung die Anzeige Einstellungen für Liveaktuaisierung sehen.

Liveaktualisierung implementieren

Anwendungssicherheit konfigurieren

Für die Integration der Liveaktualisierung ist ein Bereichselement erforderlich. Ohne dieses Element weist der Adapter Anforderungen von Clientanwendungen zurück.

Laden Sie die MobileFirst Operations Console und klicken Sie auf [Ihre Anwendung]. Klicken Sie auf der Registerkarte Sicherheit auf Zuordnung von Bereichselementen. Klicken Sie auf Neu und geben Sie das Bereichselement configuration-user-login ein. Klicken Sie dann auf Hinzufügen.

Wenn Sie in Ihrer Anwendung eine Sicherheitsüberprüfung verwenden, können Sie das Bereichselement dieser Überprüfung zuordnen.

Machen Sie sich mit dem MobileFirst-Sicherheitsframework vertraut.

Bereichszuordnung hinzufügen

Schema und Segmente

Die Anzeige “Einstellungen für Liveaktualisierung” umfasst zwei Registerkarten:

Schema

In einem Schema sind Features und Eigenschaften definiert.

  • Mit “features” können Sie konfigurierbare Anwendungsfeatures definieren und deren Standardwerte festlegen.
  • Mit “properties” können Sie konfigurierbare Anwendungseigenschaften definieren und deren Standardwerte festlegen.

Segmente

Segmente definieren ein eindeutiges Anwendungsverhalten, das durch eine Anpassung der im Schema definierten Standardfeatures und Standardeigenschaften entsteht.

Schema und Segmente hinzufügen

Bevor das Entwickler- oder Produktmanagementteam ein Schema und Segmente hinzufügt, muss eine Entscheidung bezüglich verschiedener Punkte getroffen werden:

  • Features (features), die die Liveaktualisierung nutzen sollen, und der Standardzustand dieser Features
  • Konfigurierbare Zeichenfolgen (properties) und ihre Standardwerte
  • Marktsegmente für die Anwendung

Für jedes Marktsegment muss Folgendes entschieden werden:

  • Zustand der einzelnen Features und mögliche Änderungen dieses Zustands wählrend der Anwendungslaufzeit
  • Wert der einzelnen Eigenschaften und mögliche Änderungen dieses Wertes wählrend der Anwendungslaufzeit


Sobald über die Parameter entschieden wurde, können Schemafeatures und -eigenschaften und Segmente hinzugefügt werden.
Klicken Sie dazu auf Neu und geben Sie die erforderlichen Werte an.

  • Feature: Ein Feature bestimmt, ob eine Anwendungsfunktion aktiviert oder inaktiviert ist. Wenn im Schema einer Anwendung ein Feature definiert wird, müssen folgende Elemente angegeben werden:
    • id – Eindeutige Feature-ID; nicht editierbare Zeichenfolge
    • name - Beschreibender Name des Features; editierbare Zeichenfolge
    • description – Kurzbeschreibung des Features; editierbare Zeichenfolge
    • defaultValue – Standardwert des Features, der gilt, bis er im Segment überschrieben wird (siehe "Segment" weiter unten); editierbarer boolescher Wert
  • Property: Eine Eigenschaft ist eine Schlüssel-Wert-Entität, mit der Anwendungen angepasst werden können. Wenn im Schema einer Anwendung eine Eigenschaft definiert wird, müssen folgende Elemente angegeben werden:
    • id – Eindeutige Eigenschafts-ID; nicht editierbare Zeichenfolge
    • name - Beschreibender Name der Eigenschaft; editierbare Zeichenfolge
    • description – Kurzbeschreibung der Eigenschaft; editierbare Zeichenfolge
    • defaultValue – Standardwert der Eigenschaft, der gilt, bis er im Segment überschrieben wird (siehe "Segment" weiter unten); editierbare Zeichenfolge
  • Segment: Eine Entität, die einem Marktsegment entspricht und die im Schema definierten Features und Eigenschaften sowie ggf. Vorrangwerte enthält. Wenn ein Segment definiert wird, müssen folgende Elemente angegeben werden:
    • id – Eindeutige Segmentkennung; nicht editierbare Zeichenfolge
    • name - Beschreibender Name des Segments; editierbare Zeichenfolge
    • description – Kurzbeschreibung des Segments; editierbare Zeichenfolge
    • Features - Liste der im Schema definierten Features. Der Benutzer kann ein vom Standardwert im Schema abweichenden statischen Wert für ein Feature festlegen.
    • Properties - Liste der im Schema definierten Eigenschaften. Der Benutzer kann ein vom Standardwert im Schema abweichenden statischen Wert für eine Eigenschaft festlegen.
Hinweis:
  • Wenn ein Feature oder eine Eigenschaft zum Schema hinzugefügt wird, wird automatisch zu allen Segmenten einer Anwendung ein entsprechendes Feature oder eine entsprechende Eigenschaft (mit dem Standardwert) hinzugefügt.
  • Wenn ein Feature oder eine Eigenschaft aus dem Schema entfernt wird, wird das entsprechende Feature oder die entsprechende Eigenschaft automatisch aus allen Segmenten einer Anwendung entfernt.

Schemafeatures und -eigenschaften mit Standardwerten definieren

Schemafeature- und -eigenschaft hinzufügen

Marktsegmente definieren

Segment hinzufügen

Standardwert von Features und Eigenschaften überschreiben

Sie können ein Feature aktivieren und den Standardzustand des Features ändern. Feature aktivieren

Sie können den Standardwert einer Eigenschaft überschreiben. Eigenschaft überschreiben

SDK für Liveaktualisierung zu Anwendungen hinzufügen

Das SDK für Liveaktualisierung stellt Entwicklern eine API zur Verfügung, mit der Konfigurationsfeatures und -eigenschaften abgefragt werden, die in der MobileFirst Operations Console in der Anwendungsanzeige “Einstellungen für Liveaktualisierung” definiert wurden.

Cordova-Plug-in hinzufügen

Führen Sie in Ihrer Cordova-Anwendung den folgenden Befehl aus:

cordova plugin add cordova-plugin-mfp-liveupdate

iOS-SDK hinzufügen

  1. Bearbeiten Sie die Podfile Ihrer Anwendung. Fügen Sie den Pod IBMMobileFirstPlatformFoundationLiveUpdate hinzu.
    Beispiel:

    use_frameworks!
    
    target 'your-Xcode-project-target' do
       pod 'IBMMobileFirstPlatformFoundation'
       pod 'IBMMobileFirstPlatformFoundationLiveUpdate'
    end
    
  2. Navigieren Sie in einem Befehlszeilenfenster zum Stammordner des Xcode-Projekts und führen Sie den Befehl pod install aus.

Android-SDK hinzufügen

  1. Wählen Sie in Android Studio Android → Gradle Scripts aus. Wählen Sie dann die Datei build.gradle (Module: app) aus.
  2. Fügen Sie innerhalb von dependencies den Eintrag ibmmobilefirstplatformfoundationliveupdate hinzu:

    dependencies {
         compile group: 'com.ibm.mobile.foundation',
         name: 'ibmmobilefirstplatformfoundation',
         version: '8.0.+',
         ext: 'aar',
         transitive: true
    
         compile group: 'com.ibm.mobile.foundation',
         name: 'ibmmobilefirstplatformfoundationliveupdate',
         version: '8.0.0',
         ext: 'aar',
         transitive: true
    }   
    

SDK für Liveaktualisierung

Es gibt verschiedene Einsatzstrategien für das SDK für Liveaktualisierung.

Vordefiniertes Segment

Sie können Logik zum Abrufen der Konfiguration eines relevanten Segments implementieren.
Ersetzen Sie “segment-name”, “property-name” und “feature-name” durch eigene Werte.

Cordova

    var input = { segmentId :'segment-name' };
    LiveUpdateManager.obtainConfiguration(input,function(configuration) {
        // Aktion für das Konfigurationsobjekt (JSON) ausführen, wenn Sie beispielsweise
        // im Server ein Feature mit dem Namen 'feature-name' definiert haben:
        // if (configuration.features.feature-name) {
        //   console.log(configuration.properties.property-name);
	// }
    } ,
    function(err) {
        if (err) {            
alert('liveupdate error:'+err);
        }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration("segment-name", completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

LiveUpdateManager.getInstance().obtainConfiguration("segment-name", new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
        Log.i("LiveUpdateDemo", configuration.getProperty("property-name"));
        Log.i("LiveUpdateDemo", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateDemo", wlFailResponse.getErrorMsg());
    }
});

Wenn die Konfiguration für Liveaktualisierung abgerufen wurde, können die applikative Logik und der Anwendungsablauf auf der Basis des Zustands von Features und Eigenschaften etabliert werden. Sie können beispielsweise an einem nationalen Feiertag eine neue Werbeaktion in der Anwendung lancieren.

Segment-Resolver-Adapter

Im Abschnitt Architektur für Liveaktualisierung wurde ein Segment-Resolver-Adapter erwähnt.
Dieser Adapter hat die Aufgabe, angepasste Geschäftslogik bereitzustellen, die einen segmentbasierten Anwendungs-/Geräte-/Benutzerkontext und angepasste applikative Parameter abruft.

Gehen Sie für die Verwendung eines Segment-Resolver-Adapters wie folgt vor:

  1. Erstellen Sie einen neuen Java-Adapter.
  2. Definieren Sie den Adapter unter Adapters → Live Update adapter → segmentResolverAdapterName als Segment-Resolver-Adapter.
  3. Vergessen Sie nicht, einen Adpaterbuild zu erstellen und den Adapter zu implementieren.

Der Segment-Resolver-Adapter definiert eine REST-Schnittstelle. Eine Anforderung an diesen Adapter enthält in ihrem Hauptteil alle Informationen, die benötigt werden, um zu entscheiden, zu welchem Segment der Endbenutzer gehört. Das ermittelte Segment wird zurück an die Anwendung gesendet.

Wenn Sie die einzelnen Konfigurationsparameter abrufen möchten, senden Sie die Anforderung über die API für Liveaktualisierung:

Cordova

var input = { params : { 'paramKey': 'paramValue'} ,useClientCache : true };                                                                                                    
LiveUpdateManager.obtainConfiguration(input,function(configuration) {
        // Aktion für das Konfigurationsobjekt (JSON) ausführen, z. B.
        // console.log(configuration.properties.property-name);
        // console.log(configuration.data.features.feature-name);
    } ,
    function(err) {
        if (err) {            
alert('liveupdate error:'+err);
        }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration(["paramKey":"paramValue"], completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

Map <String,String> params = new HashMap<>();
params.put("paramKey", "paramValue");

LiveUpdateManager.getInstance().obtainConfiguration(params , new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
        Log.i("LiveUpdateDemo", configuration.getProperty("property-name"));
        Log.i("LiveUpdateDemo", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateDemo", wlFailResponse.getErrorMsg());
    }
});

Adapterimplementierung

Die von der Anwendung mithilfe des Client-SDK für Liveaktualisierung bereitgestellten Argumente werden dann an den Adapter für Liveaktualisierung und von dort an den Segment-Resolver-Adapter übergeben. Diesen Schritt führt der Adapter für Liveaktualisierung automatisch aus. Eine Aktion des Entwicklers ist nicht erforderlich.

Aktualisieren Sie die Immplementierung Ihres neu erstellten Segment-Resolver-Adapters, damit von diesen Argumenten das relevante Segment zurückgegeben wird.
Dafür können Sie den folgenden Beispielcode verwenden.

Hinweis: Sie müssen die Gson-Abhängigkeit zur Datei pom.xml Ihres Adapters hinzufügen.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.7</version>
</dependency>

SampleSegmentResolverAdapterApplication.java

@Api(value = "Sample segment resolver adapter")
@Path("/")
public class SampleSegmentResolverAdapter {

    private static final Gson gson = new Gson();
    private static final Logger logger = Logger.getLogger(SampleSegmentResolverAdapter.class.getName());

    @POST
    @Path("segment")
    @Produces("text/plain;charset=UTF-8")
    @OAuthSecurity(enabled = true, scope = "configuration-user-login")
    public String getSegment(String body) throws Exception {
        ResolverAdapterData data = gson.fromJson(body, ResolverAdapterData.class);
        String segmentName = "";

        // Angepasste Argumente abrufen
        Map<String, List<String>> arguments = data.getQueryArguments();

        // authenticatedUser-Objekt abrufen
        AuthenticatedUser authenticatedUser = data.getAuthenticatedUser();
        String name = authenticatedUser.getDisplayName();

        // Registrierungsdaten abrufen (z. B. Gerät und Anwendung)
        RegistrationData registrationData = data.getRegistrationData();
        ApplicationKey application = registrationData.getApplication();
        DeviceData deviceData = registrationData.getDevice();

        // Segmentnamen auf der Basis des obigen Kontextes (arguments, authenticatedUser und registrationData) auflösen.
        // Angepasste Logik zur Auflösung des Segmentnamens schreiben

        return segmentName;
    }
}

SampleSegmentResolverAdapter.java

public class ResolverAdapterData {
    public ResolverAdapterData() {
    }

    public ResolverAdapterData(AdapterSecurityContext asc, Map<String, List<String>> queryArguments)
    {
        ClientData cd = asc.getClientRegistrationData();

        this.authenticatedUser = asc.getAuthenticatedUser();
        this.registrationData = cd == null ? null : cd.getRegistration();
        this.queryArguments = queryArguments;
    }

    public AuthenticatedUser getAuthenticatedUser() {
        return authenticatedUser;
    }

    public RegistrationData getRegistrationData() {
        return registrationData;
    }

    public Map<String, List<String>> getQueryArguments() {
        return queryArguments;
    }

    private AuthenticatedUser authenticatedUser;
    private RegistrationData registrationData;
    private Map<String, List<String>> queryArguments;
}

REST-Schnittstelle des Segment-Resolver-Adapters

Anforderung

Attribut Wert
URL /segment
Method POST
Content-type application/json
Body <JSON-Objekt mit allen erforderlichen Informationen für die Segmentauflösung>

Antwort

Attribut Wert
Content-type text/plain
Body <Zeichenfolge mit einer Beschreibung der Segment-ID>

Themen für Fortgeschrittene

Import/Export

Der Systemadministrator kann definierte Schemata und Segmente exportieren und in andere Serverinstanzen importieren.

Schema exportieren

curl --user admin:admin http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/schema > schema.txt

Schema importieren

curl -X PUT -d @schema.txt --user admin:admin -H "Content-Type:application/json" http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/schema
  • Ersetzen Sie “admin:admin” durch Ihre eigenen Werte. (Der Standardwert ist “admin”.)
  • Ersetzen Sie “localhost” und die Portnummer ggf. durch eigene Werte.
  • Ersetzen Sie die Anwendungskennung “com.sample.HelloLiveUpdate” durch die Kennung Ihrer eigenen Anwendung.

Segment(e) exportieren

curl --user admin:admin http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/segment?embedObjects=true > segments.txt

Segment(e) importieren

#!/bin/bash
segments_number=$(python -c 'import json,sys;obj=json.load(sys.stdin);print len(obj["items"]);' < segments.txt)
counter=0
while [ $segments_number -gt $counter ]
do
    segment=$(cat segments.txt | python -c 'import json,sys;obj=json.load(sys.stdin);data_str=json.dumps(obj["items"]['$counter']);print data_str;')
    echo $segment | curl -X POST -d @- --user admin:admin --header "Content-Type:application/json" http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/segment
    ((counter++))
done
  • Ersetzen Sie “admin:admin” durch Ihre eigenen Werte. (Der Standardwert ist “admin”.)
  • Ersetzen Sie “localhost” und die Portnummer ggf. durch eigene Werte.
  • Ersetzen Sie die Anwendungskennung “com.sample.HelloLiveUpdate” durch die Kennung Ihrer eigenen Anwendung.

Caching

Das Caching ist standardmäßig aktiviert, um Netzlatenzzeiten zu vermeiden. Aktualisierungen werden daher möglicherweise nicht sofort ausgeführt.
Sie können das Caching inaktivieren, wenn häufigere Aktualisierungen erforderlich sind.

Cordova

Den clientseitigen Cache können Sie mit einem optionalen booleschen Flag (useClientCache) steuern:

	var input = { segmentId :'18' ,useClientCache : false };
        LiveUpdateManager.getConfiguration(input,function(configuration) {
                // Aktion für die resultierende Konfiguration ausführen. Beispiel:
                // console.log(configuration.data.properties.property-name);
                // console.log(configuration.data.features.feature-name);
        } ,
        function(err) {
                if (err) {            
alert('liveupdate error:'+err);
                }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration("segment-name", useCache: false, completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

LiveUpdateManager.getInstance().obtainConfiguration("segment-name", false, new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
      Log.i("LiveUpdateSample", configuration.getProperty("property-name"));
      Log.i("LiveUpdateSample", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateSample", wlFailResponse.getErrorMsg());
    }
});

Cacheverfallszeit

Der Wert expirationPeriod wird unter Adapters → Live Update adapter definiert und gibt die Verfallszeit für den Cache vor.

Beispielanwendung

Beispielanwendung

Wenn Sie in der Beispielanwendung ein Landesattribut auswählen und die Liveaktualisierung anwenden, gibt die App Text in der Sprache des ausgewählten Landes aus. Wenn Sie das Kartenfeature aktivieren und die Karte bereitstellen, wird eine Karte des entsprechenden Landes angezeigt.

Klicken Sie hier, um das Xcode-Projekt herunterzuladen.
Klicken Sie hier, um das Android-Studio-Projekt herunterzuladen.

Verwendung des Beispiels

Anweisungen finden Sie in der Datei README.md zum Beispiel.

Einstellungen für Liveaktualisierung ändern

Jedes Segment emfpängt den Standardwert aus dem Schema. Ändern Sie die einzelnen Segmente entsprechend der Sprache. Fügen Sie für Französich beispielsweise Folgendes hinzu: helloText - Bonjour le monde.

Klicken Sie in der MobileFirst Operations Console unter [Ihre Anwendung] → Einstellungen für Liveaktualisierung auf der Registerkarte Segmente auf den Link Eigenschaften für die Sprache, z. B. für FR.

  • Klicken Sie auf das Symbol Bearbeiten und stellen Sie einen Link zu einem Bild bereit, das beispielsweise die Landkarte für Frankreich zeigt.
  • Wenn Sie die Karte sehen möchten, während Sie die App verwenden, müssen Sie das Feature includeMap aktivieren.
Last modified on April 25, 2017