Implementare funzionalità per gruppi di destinatari in un'applicazione Python

In questa guida si usa un filtro di destinazione per implementare una funzionalità per i destinatari di destinazione per l'applicazione Python. Per altre informazioni su questo filtro di destinazione, vedere Implementare le funzionalità ai destinatari di destinazione.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creane uno gratis.
Un negozio di configurazione delle applicazioni, come illustrato nell'esercitazione per la creazione di un negozio.
Flag di funzionalità beta con filtro di destinazione. Creare il flag di funzionalità.
Python 3.8 o versione successiva.

Creare un'applicazione Web con un flag di funzionalità

In questa sezione viene creata un'applicazione Web che usa il flag di funzionalità Beta per controllare l'accesso alla versione beta di una pagina Web.

Configurare un progetto Python Flask

Creare una cartella denominata targeting-filter-tutorial e passare a essa.
```
mkdir targeting-filter-tutorial
cd targeting-filter-tutorial
```

Creare un ambiente virtuale e attivarlo.

# For Windows
python -m venv venv
venv\Scripts\activate

# For macOS/Linux
python -m venv venv
source venv/bin/activate

Installare i pacchetti seguenti.

pip install azure-appconfiguration-provider
pip install azure-identity
pip install featuremanagement
pip install flask

Creare un nuovo file denominato app.py e aggiungere il codice seguente.

from flask import Flask

app = Flask(__name__)

if __name__ == "__main__":
    app.run(debug=True)

Connettersi ad Configurazione app di Azure

Aggiornare app.py e aggiungere il codice seguente.

from flask import Flask
import os
from azure.identity import DefaultAzureCredential
from azure.appconfiguration.provider import load
from featuremanagement import FeatureManager

app = Flask(__name__)

# Get the App Configuration endpoint from environment variables
app_config_endpoint = os.environ.get("AZURE_APPCONFIG_ENDPOINT")

# Declare App Configuration and feature manager variables
azure_app_config = None
feature_manager = None

def initialize_config():
    global azure_app_config, feature_manager
    # Load feature flags from App Configuration
    azure_app_config = load(
        endpoint=app_config_endpoint,
        credential=DefaultAzureCredential(),
        feature_flag_enabled=True,
        feature_flag_refresh_enabled=True
    )

    # Create a feature manager with the loaded configuration
    feature_manager = FeatureManager(azure_app_config)

# Flask route before the request to refresh configuration
@app.before_request
def refresh_config():
    if azure_app_config:
        azure_app_config.refresh()

if __name__ == "__main__":
    # Initialize configuration before starting the app
    initialize_config()

    app.run(debug=True)

Connetti ad Configurazione app di Azure per caricare i flag di funzionalità, abilitare l'aggiornamento automatico e creare un oggetto FeatureManager per accedere ai flag di funzionalità in un secondo momento. L'elemento app.before_request Decorator garantisce che la configurazione venga aggiornata prima di ogni richiesta.

Usare il flag di funzionalità

Aggiungere il codice seguente al file app.py prima della funzione principale per creare un gestore di route per l'applicazione Flask. L'applicazione gestisce contenuti diversi in base al fatto che il flag di funzionalità beta sia abilitato.

@app.route("/")
def home():
    is_beta_enabled = feature_manager.is_enabled("Beta")

    title = "Home Page"
    message = "Welcome."

    if is_beta_enabled:
        title = "Beta Page"
        message = "This is a beta page."
    
    return f"""
    <!DOCTYPE html>
    <html>
        <head><title>{title}</title></head>
        <body style="display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
            <h1 style="text-align: center; font-size: 5rem;">{message}</h1>
        </body>
    </html>
    """

Abilitare la selezione dell'applicazione Web come destinazione

Quando si valutano le funzionalità con la destinazione abilitata, è necessario un contesto di destinazione. In Python è necessario creare un TargetingContext oggetto e passarlo al is_enabled metodo di gestione delle funzionalità.

Aggiornare il file app.py per importare la TargetingContext classe e usarla nella home route:

from flask import Flask, request
from featuremanagement import FeatureManager, TargetingContext

...

@app.route("/")
def home():
    # Get targeting context from query parameters
    user_id = request.args.get("userId", "")
    groups_param = request.args.get("groups", "")
    groups = groups_param.split(",") if groups_param else []

    targeting_context = TargetingContext(user_id=user_id, groups=groups)
    is_beta_enabled = feature_manager.is_enabled("Beta", targeting_context)
    

    title = "Home Page"
    message = "Welcome."

    if is_beta_enabled:
        title = "Beta Page"
        message = "This is a beta page."

    
    return f"""
    <!DOCTYPE html>
    <html>
        <head><title>{title}</title></head>
        <body style="display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
            <h1 style="text-align: center; font-size: 5rem;">{message}</h1>
        </body>
    </html>
    """

if __name__ == "__main__":
    # Initialize configuration before starting the app
    initialize_config()

    app.run(debug=True)

Filtro di destinazione in azione

Impostare la variabile di ambiente denominata AZURE_APPCONFIG_ENDPOINT sull'endpoint dell'archivio di Configurazione app disponibile in Panoramica dello store nel portale di Azure.

Se si usa il prompt dei comandi di Windows, eseguire il comando seguente e riavviare il prompt per rendere effettiva la modifica:
```
setx AZURE_APPCONFIG_ENDPOINT "<AppConfigurationEndpoint>"
```
Se si usa PowerShell, eseguire il comando seguente:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<AppConfigurationEndpoint>"
```
Se si usa macOS o Linux, eseguire il comando seguente:
```
export AZURE_APPCONFIG_ENDPOINT='<AppConfigurationEndpoint>'
```
Eseguire l'applicazione.
```
python app.py
```
Aprire il browser e passare all'indirizzo visualizzato nel terminale (per impostazione predefinita, http://127.0.0.1:5000). Verrà visualizzata la visualizzazione predefinita dell'app.
Aggiungere userId come parametro di query nell'URL per specificare l'ID utente. Visitare localhost:5000/?userId=test@contoso.com. Viene visualizzata la pagina beta, perché test@contoso.com è specificato come utente target.
Visitare localhost:5000/?userId=testuser@contoso.com. Non è possibile visualizzare la pagina beta perché testuser@contoso.com è specificata come utente escluso.

Passaggi successivi

Per altre informazioni sui filtri delle funzionalità, continuare con i documenti seguenti.

Abilitare le funzionalità condizionali con filtri di funzionalità

Abilitare le funzionalità in base a una pianificazione

Per altre informazioni sulla libreria Gestione funzionalità Python, continuare con il documento seguente.

Gestione delle funzionalità per Python

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-06-26