Implementar recursos para públicos-alvo em um aplicativo Python

Neste guia, você usa um filtro de segmentação para implementar um recurso para públicos-alvo para seu aplicativo Python. Para obter mais informações sobre esse filtro de segmentação, consulte Implantar recursos para públicos-alvo.

Pré-requisitos

Criar um aplicativo Web com um sinalizador de recurso

Nesta seção, você cria um aplicativo Web que usa o sinalizador de recurso Beta para controlar o acesso à versão beta de uma página da Web.

Configurar um projeto Python Flask

  1. Crie uma pasta chamada targeting-filter-tutorial e navegue até ela.

    mkdir targeting-filter-tutorial
cd targeting-filter-tutorial

  2. Crie um ambiente virtual e ative-o.

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

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

  3. Instale os seguintes pacotes.

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

  4. Crie um novo arquivo chamado app.py e adicione o código a seguir.

    from flask import Flask

app = Flask(__name__)

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

Conectar-se à Configuração do Aplicativo do Azure

  1. Atualize app.py e adicione o código a seguir.

    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)

    Você se conecta à Configuração do Aplicativo do Azure para carregar sinalizadores de recursos, habilitar a atualização automática e criar um FeatureManager objeto para acessar sinalizadores de recursos posteriormente. O app.before_request decorador garante que a configuração seja atualizada antes de cada solicitação.

Utilize o sinalizador de funcionalidade

Adicione o seguinte código ao ficheiro app.py antes da função principal para criar um gestor de rotas para a aplicação Flask. A aplicação apresenta conteúdos diferentes consoante a flag de funcionalidade Beta estar ou não ativada.

@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>
    """

Habilitar a segmentação para o aplicativo Web

Um contexto de segmentação é necessário ao avaliar recursos com a segmentação habilitada. Em Python, você precisa criar um TargetingContext objeto e passá-lo para o is_enabled método do gerenciador de recursos.

Atualize o arquivo app.py para importar a TargetingContext classe e usá-la na rota inicial:

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 de direcionamento em ação

  1. Defina a variável de ambiente chamada AZURE_APPCONFIG_ENDPOINT para o ponto de extremidade da sua loja de Configuração de Aplicativos encontrado em Visão geral da sua loja no portal do Azure.

    Se você usar o prompt de comando do Windows, execute o seguinte comando e reinicie o prompt de comando para permitir que a alteração entre em vigor:

    setx AZURE_APPCONFIG_ENDPOINT "<AppConfigurationEndpoint>"

    Se você usar o PowerShell, execute o seguinte comando:

    $Env:AZURE_APPCONFIG_ENDPOINT = "<AppConfigurationEndpoint>"

    Se você usa macOS ou Linux, execute o seguinte comando:

    export AZURE_APPCONFIG_ENDPOINT='<AppConfigurationEndpoint>'

  2. Execute o aplicativo.

    python app.py

  3. Abra o navegador e navegue até o endereço exibido no terminal (por padrão, http://127.0.0.1:5000). Você deve ver a visualização padrão do aplicativo.

    Captura de ecrã da aplicação, mostrando a mensagem de saudação predefinida.

  4. Adicione userId como um parâmetro de consulta na URL para especificar o ID do usuário. Visite localhost:5000/?userId=test@contoso.com. Você vê a página beta, porque test@contoso.com é especificado como um usuário alvo.

    Captura de ecrã da aplicação, mostrando a página beta.

  5. Visite localhost:5000/?userId=testuser@contoso.com. Você não pode ver a página beta, porque testuser@contoso.com é especificado como um usuário excluído.

    Captura de ecrã da aplicação, mostrando o conteúdo predefinido.

Próximos passos

Para saber mais sobre filtros de recursos, consulte os documentos seguintes.

Habilitar recursos condicionais com filtros de recursos

Ativar funcionalidades num agendamento

Para obter mais informações sobre a biblioteca Python Feature Management, continue para o seguinte documento.

Gerenciamento de recursos para Python

  • Last updated on