Tutorial: Ausführen von Experimenten mit Featureflags für Varianten (Vorschau)

Artikel
05/21/2024

Das Ausführen von Experimenten für Ihre Anwendung kann Ihnen helfen, fundierte Entscheidungen zu treffen, um die Leistung und Benutzerfreundlichkeit Ihrer App zu verbessern. In diesem Handbuch erfahren Sie, wie Sie Experimente in einem App Configuration-Speicher einrichten und ausführen. Sie erfahren, wie Sie Daten sammeln und messen, indem Sie die Funktionen von App Configuration, Application Insights (Vorschau) und Split Experimentation Workspace (Vorschau) verwenden.

Auf diese Weise können Sie datengestützte Entscheidungen treffen, um Ihre Anwendung zu verbessern.

Hinweis

Eine schnelle Möglichkeit, um mit dem Experimentieren zu beginnen, besteht darin, das AZD-Beispiel für das Zitat des Tages auszuführen. Dieses Repository bietet ein umfassendes Beispiel, das die Bereitstellung von Azure-Ressourcen und ein erstes Experiment zum Integrieren von Azure App Configuration in Ihre .NET-Anwendungen zum Ausführen von Experimenten umfasst.

In diesem Tutorial:

Erstellen eines Variantenfeatureflags
Hinzufügen einer Application Insights-Ressource zu Ihrem Speicher
Hinzufügen eines Split Experimentation Workspace zu Ihrem Speicher
Einrichten einer App zum Ausführen eines Experiments
Aktivieren von Telemetrie und Erstellen eines Experiments in Ihrem Variantenfeatureflag
Erstellen von Metriken für Ihr Experiment
Abrufen von Experimentergebnissen

Voraussetzungen

Ein Azure-Abonnement. Wenn Sie dies nicht haben, können Sie es kostenlos erstellen.
Ein App Configuration-Speicher.
Eine Split Experimentation Workspace-Ressource.
Eine arbeitsbereichbasierte Application Insights-Ressource.

Erstellen eines Variantenfeatureflags (Vorschau)

Erstellen Sie ein Variantenfeatureflag namens Greeting mit zwei Varianten, Off und On, wie in der Schnellstartanleitung für Featureflags beschrieben.

Verbinden einer Application Insights -Ressource (Vorschau) mit Ihrem Konfigurationsspeicher

Zum Ausführen eines Experiments müssen Sie zunächst eine arbeitsbereichbasierte Application Insights-Ressource mit Ihrem App Configuration-Speicher verbinden. Wenn Sie diese Ressource mit Ihrem App Configuration-Speicher verbinden, wird der Konfigurationsspeicher mit der Telemetriequelle für das Experiment festgelegt.

Wählen Sie im App Configuration-Speicher Telemetrie > Application Insights (Vorschau) aus.
Wählen Sie die Application Insights-Ressource aus, die Sie als Telemetrieanbieter für Ihre Variantenfeatureflags und die Anwendung verwenden möchten, und wählen Sie Speichern aus. Wenn Sie keine Application Insights-Ressource haben, erstellen Sie eine Ressource, indem Sie Neu erstellen auswählen. Weitere Informationen zum Fortfahren finden Sie im Artikel zum Erstellen einer arbeitsbereichbasierten Ressource. Laden Sie dann in Application Insights (Vorschau) die Liste der verfügbaren Application Insights-Ressourcen neu, und wählen Sie Ihre neue Application Insights-Ressource aus.
Eine Benachrichtigung gibt an, dass die Application Insights-Ressource für den App Configuration-Speicher aktualisiert wurde.

Verbinden von Split Experimentation Workspace (Vorschau) mit dem Speicher

Um Experimente in Azure App Configuration auszuführen, verwenden Sie Split Experimentation Workspace. Führen Sie die folgenden Schritte aus, um einen Split Experimentation Workspace mit Ihrem Store zu verbinden.

Wählen Sie im App Configuration-Speicher Experimentation>Split Experimentation Workspace (preview) aus dem linken Menü aus.
Wählen Sie einen Split Experimentation Workspace und dann Speichern aus. Wenn Sie keinen Split Experimentation Workspace haben, folgen Sie der Schnellstartanleitung zu Split Experimentation Workspace, um einen zu erstellen.

Hinweis

Die im Split Experimentation Workspace ausgewählte Datenquelle muss dieselbe Application Insights-Ressource wie die im vorherigen Schritt ausgewählte Ressource sein.
Eine Benachrichtigung gibt an, dass der Vorgang erfolgreich war.

Einrichten einer App zum Ausführen eines Experiments

Nachdem Sie nun die Application Insights-Ressource (Vorschau) mit dem App Configuration-Speicher verbunden haben, richten Sie eine App ein, um Ihr Experiment auszuführen (Vorschau).

In diesem Beispiel erstellen Sie eine ASP.NET-Web-App mit dem Namen Quote of the day. Wenn die App geladen wird, wird ein Zitat angezeigt. Benutzer können auf die Herzschaltfläche klicken, um dies mit „Gefällt mir“ zu markieren. Um die Benutzerbindung zu verbessern, sollten Sie untersuchen, ob eine personalisierte Begrüßungsnachricht die Anzahl der Benutzer erhöht, die das Zitat mögen. Sie erstellen das Featureflag Greeting in Azure App Configuration mit zwei Varianten: Off und On. Benutzer, die die Off-Variante erhalten, sehen einen Standardtitel. Benutzer, die die On-Variante erhalten, sehen eine Begrüßungsnachricht. Sie sammeln und speichern die Telemetrie Ihrer Benutzerinteraktionen in Application Insights. Mit Split Experimentation Workspace können Sie die Effektivität Ihres Experiments analysieren.

Erstellen einer App und Hinzufügen von geheimen Benutzerschlüsseln

Öffnen Sie eine Eingabeaufforderung, und führen Sie den folgenden Code aus. Dadurch wird eine neue Razor Pages-Anwendung in ASP.NET Core mit der Einzelkontoauthentifizierung erstellt und in einem Ausgabeordner namens QuoteOfTheDay platziert.
```
dotnet new razor --auth Individual -o QuoteOfTheDay
```
Navigieren Sie in der Eingabeaufforderung zum Ordner QuoteOfTheDay, und führen Sie den folgenden Befehl aus, um einen geheimen Benutzerschlüssel für die Anwendung zu erstellen. Der Schlüssel enthält die Verbindungszeichenfolge für App Configuration.
```
dotnet user-secrets set ConnectionStrings:AppConfiguration "<App Configuration Connection string>"
```
Erstellen Sie einen anderen geheimen Benutzerschlüssel, der die Verbindungszeichenfolge für Application Insights enthält.
```
dotnet user-secrets set ConnectionStrings:AppInsights "<Application Insights Connection string>"
```

Aktualisieren des Anwendungscodes

Fügen Sie in QuoteOfTheDay.csproj die neuesten Vorschauversionen der Feature Management- und App Configuration-SDKs als erforderliche Pakete hinzu.

<PackageReference Include="Microsoft.Azure.AppConfiguration.AspNetCore" Version="8.0.0-preview.2" />
<PackageReference Include="Microsoft.FeatureManagement.Telemetry.ApplicationInsights" Version="4.0.0-preview3" />
<PackageReference Include="Microsoft.FeatureManagement.Telemetry.ApplicationInsights.AspNetCore" Version="4.0.0-preview3" />
<PackageReference Include="Microsoft.FeatureManagement.AspNetCore" Version="4.0.0-preview3" />

Fügen Sie in Program.cs unter der Zeile var builder = WebApplication.CreateBuilder(args); den App Configuration-Anbieter hinzu, der die Konfiguration von Azure abruft, wenn die Anwendung gestartet wird. Standardmäßig enthält die UseFeatureFlags-Methode alle Featureflags ohne Bezeichnung und legt eine Cache-Ablaufzeit von 30 Sekunden fest.
```
builder.Configuration
    .AddAzureAppConfiguration(o =>
    {
        o.Connect(builder.Configuration.GetConnectionString("AppConfiguration"));

        o.UseFeatureFlags();
    });
```

Öffnen Sie Program.cs, und fügen Sie Folgendes per Anweisungen hinzu:

using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.FeatureManagement.Telemetry.ApplicationInsights.AspNetCore;

Fügen Sie unter der Stelle, an der builder.Configuration.AddAzureAppConfiguration aufgerufen wird, Folgendes hinzu:
```
// Add Application Insights telemetry.
builder.Services.AddApplicationInsightsTelemetry(
    new ApplicationInsightsServiceOptions
    {
        ConnectionString = builder.Configuration.GetConnectionString("AppInsights"),
        EnableAdaptiveSampling = false
    })
    .AddSingleton<ITelemetryInitializer, TargetingTelemetryInitializer>();
```
Dieser Codeschnipsel führt folgende Aktionen aus.
- Fügt der Anwendung einen Application Insights-Telemetrieclient hinzu.
- Fügt einen Telemetrieinitialisierer hinzu, der Zielinformationen an ausgehende Telemetrie anfügt.
- Deaktiviert die adaptive Stichprobenerstellung. Weitere Informationen zum Deaktivieren der adaptiven Stichprobenerstellung finden Sie unter Problembehandlung.

Erstellen Sie im Stammordner QuoteOfTheDay eine neue Datei mit dem Namen ExampleTargetingContextAccessor.cs. Damit wird eine neue Klasse namens ExampleTargetingContextAccessor erstellt. Fügen Sie den unten stehenden Inhalt in die Datei ein.

using Microsoft.FeatureManagement.FeatureFilters;

namespace QuoteOfTheDay
{
    public class ExampleTargetingContextAccessor : ITargetingContextAccessor
    {
        private const string TargetingContextLookup = "ExampleTargetingContextAccessor.TargetingContext";
        private readonly IHttpContextAccessor _httpContextAccessor;

        public ExampleTargetingContextAccessor(IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
        }

        public ValueTask<TargetingContext> GetContextAsync()
        {
            HttpContext httpContext = _httpContextAccessor.HttpContext;
            if (httpContext.Items.TryGetValue(TargetingContextLookup, out object value))
            {
                return new ValueTask<TargetingContext>((TargetingContext)value);
            }
            List<string> groups = new List<string>();
            if (httpContext.User.Identity.Name != null)
            {
                groups.Add(httpContext.User.Identity.Name.Split("@", StringSplitOptions.None)[1]);
            }
            TargetingContext targetingContext = new TargetingContext
            {
                UserId = httpContext.User.Identity.Name ?? "guest",
                Groups = groups
            };
            httpContext.Items[TargetingContextLookup] = targetingContext;
            return new ValueTask<TargetingContext>(targetingContext);
        }
    }
}

Diese Klasse deklariert, wie die FeatureManagement-Zielgruppenadressierung den Kontext für einen Benutzer abruft. In diesem Fall wird httpContext.User.Identity.Name für UserId gelesen, und die Domäne der E-Mail-Adresse wird als Group behandelt.

Navigieren Sie zurück zu Program.cs, und fügen Sie Folgendes mithilfe von Anweisungen ein.

using Microsoft.FeatureManagement.Telemetry;
using Microsoft.FeatureManagement;
using QuoteOfTheDay;

Fügen Sie unter der Stelle, an der AddApplicationInsightsTelemetry aufgerufen wurde, Dienste zum Behandeln von App Configuration Refresh hinzu, richten Sie die Featureverwaltung ein, konfigurieren Sie die Featureverwaltungsadressierung, und aktivieren Sie die Featureverwaltung, um Telemetrieereignisse zu veröffentlichen.
```
builder.Services.AddHttpContextAccessor();

// Add Azure App Configuration and feature management services to the container.
builder.Services.AddAzureAppConfiguration()
    .AddFeatureManagement()
    .WithTargeting<ExampleTargetingContextAccessor>()
    .AddTelemetryPublisher<ApplicationInsightsTelemetryPublisher>();
```
Fügen Sie unter der Zeile var app = builder.Build(); eine Middleware hinzu, die bei Bedarf die App Configuration-Aktualisierung auslöst.
```
// Use Azure App Configuration middleware for dynamic configuration refresh.
app.UseAzureAppConfiguration();
```
Fügen Sie darunter den folgenden Code hinzu, damit TargetingTelemetryInitializer Zugriff auf Zielgruppeninformationen durch Speichern in HttpContext erhält.
```
// Add TargetingId to HttpContext for telemetry
app.UseMiddleware<TargetingHttpContextMiddleware>();
```
Fügen Sie in QuoteOfTheDay>Pages>Shared>_Layout.cshtml unter der Stelle, an der QuoteOfTheDay.styles.css hinzugefügt wurde, die folgende Zeile hinzu, um das CSS für Version 5.15.3 von font-awesome hinzuzufügen.
```
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">
```

Öffnen Sie QuoteOfTheDay>Pages>Index.cshtml.cs, und überschreiben Sie den Inhalt mit der Zitat-App.

using Microsoft.ApplicationInsights;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.FeatureManagement;

namespace QuoteOfTheDay.Pages;

public class Quote
{
    public string Message { get; set; }

    public string Author { get; set; }
}

public class IndexModel(IVariantFeatureManagerSnapshot featureManager, TelemetryClient telemetryClient) : PageModel
{
    private readonly IVariantFeatureManagerSnapshot _featureManager = featureManager;
    private readonly TelemetryClient _telemetryClient = telemetryClient;

    private Quote[] _quotes = [
        new Quote()
        {
            Message = "You cannot change what you are, only what you do.",
            Author = "Philip Pullman"
        }];

    public Quote? Quote { get; set; }

    public bool ShowGreeting { get; set; }

    public async void OnGet()
    {
        Quote = _quotes[new Random().Next(_quotes.Length)];

        Variant variant = await _featureManager.GetVariantAsync("Greeting", HttpContext.RequestAborted);

        ShowGreeting = variant.Configuration.Get<bool>();
    }

    public IActionResult OnPostHeartQuoteAsync()
    {
        string? userId = User.Identity?.Name;

        if (!string.IsNullOrEmpty(userId))
        {
            // Send telemetry to Application Insights
            _telemetryClient.TrackEvent("Like");

            return new JsonResult(new { success = true });
        }
        else
        {
            return new JsonResult(new { success = false, error = "User not authenticated" });
        }
    }
}

Dieses PageModel wählt ein zufälliges Zitat aus, verwendet GetVariantAsync, um die Variante für den aktuellen Benutzer abzurufen, und legt eine Variable namens „ShowGreeting“ auf den Wert der Variante fest. Das PageModel verarbeitet auch Post-Anforderungen und ruft _telemetryClient.TrackEvent("Like"); auf, wodurch ein Ereignis mit dem Namen Like an Application Insights gesendet wird. Dieses Ereignis ist automatisch an den Benutzer und die Variante gebunden und kann von Metriken nachverfolgt werden.

Öffnen Sie index.cshtml, und überschreiben Sie den Inhalt für die Zitat-App.

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
    ViewData["Username"] = User.Identity.Name;
}

<style>
    body {
        font-family: Arial, sans-serif;
        background-color: #f4f4f4;
        color: #333;
    }

    .quote-container {
        background-color: #fff;
        margin: 2em auto;
        padding: 2em;
        border-radius: 8px;
        max-width: 750px;
        box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.2);
        display: flex;
        justify-content: space-between;
        align-items: start;
        position: relative;
    }

    .vote-container {
        position: absolute;
        top: 10px;
        right: 10px;
        display: flex;
        gap: 0em;
    }

    .vote-container .btn {
        background-color: #ffffff; /* White background */
        border-color: #ffffff; /* Light blue border */
        color: #333
    }

    .vote-container .btn:focus {
        outline: none;
        box-shadow: none;
    }

    .vote-container .btn:hover {
        background-color: #F0F0F0; /* Light gray background */
    }

    .greeting-content {
        font-family: 'Georgia', serif; /* More artistic font */
    }

    .quote-content p.quote {
        font-size: 2em; /* Bigger font size */
        font-family: 'Georgia', serif; /* More artistic font */
        font-style: italic; /* Italic font */
        color: #4EC2F7; /* Medium-light blue color */
    }
</style>

<div class="quote-container">
    <div class="quote-content">
        @if (Model.ShowGreeting)
        {
            <h3 class="greeting-content">Hi <b>@User.Identity.Name</b>, hope this makes your day!</h3>
        }
        else
        {
            <h3 class="greeting-content">Quote of the day</h3>
        }
        <br />
        <p class="quote">“@Model.Quote.Message”</p>
        <p>- <b>@Model.Quote.Author</b></p>
    </div>

    <div class="vote-container">
        <button class="btn btn-primary" onclick="heartClicked(this)">
            <i class="far fa-heart"></i> <!-- Heart icon -->
        </button>
    </div>

    <form action="/" method="post">
        @Html.AntiForgeryToken()
    </form>
</div>

<script>
    function heartClicked(button) {
        var icon = button.querySelector('i');
        icon.classList.toggle('far');
        icon.classList.toggle('fas');

        // If the quote is hearted
        if (icon.classList.contains('fas')) {
            // Send a request to the server to save the vote
            fetch('/Index?handler=HeartQuote', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'RequestVerificationToken': document.querySelector('input[name="__RequestVerificationToken"]').value
                }
            });
        }
    }
</script>

Dieser Code entspricht der Benutzeroberfläche zum Anzeigen von QuoteOfTheDay und bearbeitet die Herzaktion für ein Zitat. Er verwendet den zuvor erwähnten Model.ShowGreeting-Wert, um je nach Variante unterschiedliche Elemente für unterschiedliche Benutzer anzuzeigen.

Erstellen und Ausführen der App

Führen Sie in der Eingabeaufforderung im Ordner QuoteOfTheDay Folgendes aus: dotnet build.
Führen Sie dotnet run --launch-profile https aus.
Suchen Sie nach einer Nachricht im Format Now listening on: https://localhost:{port} in der Ausgabe der Anwendung. Navigieren Sie zu dem enthaltenen Link in Ihrem Browser.
Wählen Sie nach dem Anzeigen der ausgeführten Anwendung Registrieren oben rechts aus, um einen neuen Benutzer zu registrieren.
Registriert einen neuen Benutzer mit dem Namen user@contoso.com. Das Kennwort muss mindestens 6 Zeichen lang sein und muss eine Ziffer und ein Sonderzeichen enthalten.
Wählen Sie nach der Eingabe der Benutzerinformationen den Link Click here to validate email aus.
Registrieren Sie einen zweiten Benutzer namens userb@contoso.com, geben Sie ein anderes Kennwort ein, und validieren Sie diese zweite E-Mail-Adresse.

Hinweis

Es ist wichtig, dass in diesem Tutorial genau diese Namen verwendet werden. Solange das Feature wie erwartet konfiguriert wurde, sollten die beiden Benutzer unterschiedliche Varianten sehen.
Wählen Sie Login oben rechts aus, um sich als „userb“ (userb@contoso.com) anzumelden.
Nach der Anmeldung sollten Sie sehen, dass für userb@contoso.com beim Anzeigen der App eine spezielle Meldung angezeigt wird.

userb@contoso.com ist der einzige Benutzer, der die spezielle Nachricht sieht.

Aktivieren von Telemetrie und Erstellen eines Experiments in Ihrem Variantenfeatureflag

Aktivieren Sie Telemetrie, und erstellen Sie ein Experiment in Ihrem Variantenfeatureflag, indem Sie folgende Schritte ausführen:

Wechseln Sie im App Configuration-Speicher zu Vorgänge>Feature-Manager.
Wählen Sie das Kontextmenü (...) ganz rechts neben dem Variantenfeatureflag „Greeting“ aus, und wählen Sie Bearbeiten aus.
Wechseln Sie zur Registerkarte Telemetry, und aktivieren Sie das Kontrollkästchen Enable telemetry.
Wechseln Sie zur Registerkarte Experiment, aktivieren Sie das Kontrollkästchen Create experiment, und geben Sie Ihrem Experiment einen Namen.
Wählen Sie Select Review + update und dann Update aus.
Eine Benachrichtigung gibt an, dass der Vorgang erfolgreich war. Im Feature-Manager- sollte für das Variantenfeatureflag das Wort Active unter Experiment angezeigt werden.

Erstellen von Metriken für Ihr Experiment

Eine Metrik in Split Experimentation Workspace ist ein quantitatives Maß für ein Ereignis, das an Application Insights gesendet wird. Diese Metrik hilft dabei, die Auswirkungen eines Featureflags auf das Benutzerverhalten und die Ergebnisse zu bewerten.

Als Sie Ihre App vorher aktualisiert haben, haben Sie dem Anwendungscode _telemetryClient.TrackEvent("Like") hinzugefügt. Like ist ein Telemetrieereignis, das eine Benutzeraktion darstellt, in diesem Fall das Auswählen der Herzschaltfläche. Dieses Ereignis wird an die Application Insights-Ressource gesendet, die Sie mit der Metrik verbinden, die Sie erstellen möchten. Die von uns erstellte App gibt nur ein Ereignis an, Sie können jedoch mehrere Ereignisse und demzufolge mehrere Metriken haben. Es können auch mehrere Metriken auf einem einzigen Application Insight-Ereignis basieren.

Navigieren Sie zur Split Experimentation Workspace-Ressource. Wählen Sie unter Configuration>Experimentation Metrics die Option Create aus.

Wählen Sie die folgenden Informationen unter Create an Experimentation Metric aus, oder geben Sie sie ein. Speichern Sie dann mit Create.

Screenshot: Azure-Portal, in dem eine neue Experimentmetrik erstellt wird.

Einstellung	Beispielwert	Beschreibung
Name	Heart Vote	Der Name der Experimentmetrik.
Beschreibung	Count number of people who select the heart button when they see a special message, vs. when they don't.	Optionale Beschreibung der Metrik.
Application Insights Event Name	Like	Der Name des Application Insights-Ereignisses. Bei diesem Namen wird die Groß-/Kleinschreibung beachtet, und es ist der Name, der in Ihrem Code mit `_telemetryClient.TrackEvent("<Event-Name>")` angegeben ist.
Measure as	Count	Die folgenden Optionen sind verfügbar: Count: Zählt, wie oft das Ereignis von Ihren Benutzern ausgelöst wird. Average: Durchschnittswert des Ereignisses für Ihre Benutzer. Sum: Addiert die Werte des Ereignisses für Ihre Benutzer. Zeigt den durchschnittlichen Summenwert an. Percent: Berechnet den Prozentsatz der Benutzer, die das Ereignis ausgelöst haben.
Desired Impact	Menge erhöhen	Diese Einstellung stellt das übergeordnete Ziel oder den Zweck für die Messung der erstellten Metrik dar.

In diesem Tutorial ist unsere Hypothese, dass mehr Benutzer auf die Herzschaltfläche klicken, wenn neben dem Zitat des Tages eine besondere Nachricht vorhanden ist. Der Anwendungscode verfolgt diesen Klick als Ereignis mit dem Namen Like. Die Anwendung sendet das Like-Ereignis als Telemetrie an Application Insights. Desired Impact für dieses Experiment besteht darin, eine Steigerung bei der Anzahl der Benutzerklicks (gemessen als Count) für Heart Vote zu erreichen, um die gegebene Hypothese zu bestätigen. Wenn die Anzahl der Klicks auf die Schaltfläche abnimmt, obwohl der zugewiesenen Zielgruppe eine spezielle Nachricht angezeigt wird, wird die Hypothese für dieses Experiment widerlegt.

Nach der Erstellung wird die neue Metrik im Portal angezeigt. Sie können sie bearbeiten oder löschen, indem Sie auf der rechten Seite des Bildschirms das Kontextmenü (...) auswählen.

Abrufen von Experimentergebnissen

Um ihr neu eingerichtetes Experiment zu testen und Ergebnisse zu generieren, die Sie analysieren können, simulieren Sie Datenverkehr für Ihre Anwendung, und warten Sie 10 bis 15 Minuten.

Um die Ergebnisse Ihres Experiments anzuzeigen, navigieren Sie zum Feature-Manager, und klicken Sie in der Liste der Variantenfeatureflags auf ...>Experiment, oder wählen Sie den Link Aktiv in der Spalte Experiment aus. Diese Spalte wird standardmäßig nicht angezeigt. Um sie anzuzeigen, wählen Sie im Feature-Manager die Optionen Ansicht verwalten>Spalten bearbeiten>Spalte hinzufügen>Experiment und Anwenden aus.

Auf der Ergebnisseite sind eine Version des Experiments, ein Baseline zum Vergleichen der Ergebnisse und standardmäßig eine Comparison-Variante ausgewählt. Ändern Sie bei Bedarf die Standardeinstellungen, und wählen Sie dann Anwenden aus, um das Ergebnis Ihres Experiments anzuzeigen.

Der obige Screenshot zeigt, dass das Experiment das gewünschte Ergebnis hatte: Die On-Variante für Heart Vote führte zu 560,62 % mehr „Gefällt mir“-Markierungen als die Off-Variante.

Jede Bearbeitung an einem Variantenfeatureflag generiert eine neue Version des Experiments, die Sie auswählen können, um die Ergebnisse anzuzeigen.

Hinweis

Um Experimentergebnisse zu erhalten, benötigen Sie mindestens 30 Ereignisse pro Variante. Wir empfehlen allerdings mehr als die Mindeststichprobengröße, um sicherzustellen, dass Ihr Experiment zuverlässige Ergebnisse liefert.

Hinweis

Die Stichprobenentnahme in Application Insights ist standardmäßig aktiviert und kann sich auf Ihre Experimentergebnisse auswirken. Für dieses Tutorial sollten Sie die Stichprobenentnahme in Application Insights deaktivieren. Weitere Informationen finden Sie unter Stichprobenentnahme in Application Insights.

Nächster Schritt

Weitere Informationen zu den Experimentierkonzepten finden Sie im folgenden Dokument.

Experimentieren

Eine vollständige Übersicht über die .NET-Featureverwaltungsbibliothek finden Sie im folgenden Dokument.

.NET-Featureverwaltung

Freigeben über

Tutorial: Ausführen von Experimenten mit Featureflags für Varianten (Vorschau)

Voraussetzungen

Erstellen eines Variantenfeatureflags (Vorschau)

Verbinden einer Application Insights -Ressource (Vorschau) mit Ihrem Konfigurationsspeicher

Verbinden von Split Experimentation Workspace (Vorschau) mit dem Speicher

Einrichten einer App zum Ausführen eines Experiments

Erstellen einer App und Hinzufügen von geheimen Benutzerschlüsseln

Aktualisieren des Anwendungscodes

Erstellen und Ausführen der App

Aktivieren von Telemetrie und Erstellen eines Experiments in Ihrem Variantenfeatureflag

Erstellen von Metriken für Ihr Experiment

Abrufen von Experimentergebnissen

Nächster Schritt

Feedback

Zusätzliche Ressourcen