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

Neste guia, você usa um filtro de direcionamento para distribuir um recurso para públicos-alvo para seu aplicativo Python. Para obter mais informações sobre esse filtro de direcionamento, consulte Distribuir recursos para públicos-alvo.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie um gratuitamente.
Um repositório de Configuração de Aplicativos, conforme mostrado no tutorial para criar um repositório.
Um sinalizador de recurso Beta com filtro de direcionamento. Crie o sinalizador de recurso.
Python 3.8 ou posterior.

Crie um aplicativo Web com um sinalizador de recurso

Nesta seção, você criará 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 do Python Flask

Crie uma pasta chamada targeting-filter-tutorial e navegue até ela.
```
mkdir targeting-filter-tutorial
cd targeting-filter-tutorial
```

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

Instale os seguintes pacotes.

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

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 de Aplicativos do Azure

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)

Conecte-se à Configuração de Aplicativos 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.

Usar o sinalizador de recurso

Adicione o código a seguir ao arquivo app.py antes da função principal para criar um manipulador de rotas para o aplicativo Flask. O aplicativo fornece conteúdo diferente com base em se o sinalizador de recurso Beta está habilitado.

@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 o direcionamento para o aplicativo Web

Um contexto de direcionamento é necessário ao avaliar os recursos com o direcionamento habilitado. No 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

Defina a variável de ambiente denominada AZURE_APPCONFIG_ENDPOINT para o ponto de extremidade do repositório de Configuração de Aplicativos encontrado na Visão Geral do seu repositório no portal do Azure.

Se você usar o prompt de comando do Windows, execute o comando a seguir 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 comando a seguir:
```
export AZURE_APPCONFIG_ENDPOINT='<AppConfigurationEndpoint>'
```
Execute o aplicativo.
```
python app.py
```
Abra o navegador e navegue até o endereço exibido no terminal (por padrão). http://127.0.0.1:5000 Você deve ver o modo de exibição padrão do aplicativo.
Adicione userId como um parâmetro de consulta na URL para especificar a ID do usuário. Acesse localhost:5000/?userId=test@contoso.com. Você vê a página beta, porque test@contoso.com é especificado como usuário de destino.
Acesse localhost:5000/?userId=testuser@contoso.com. Não é possível ver a página beta, pois testuser@contoso.com é especificado como um usuário excluído.

Próximas etapas

Para saber mais sobre filtros de recursos, prossiga para os documentos a seguir.

Habilitar recursos condicionais com filtros de recursos

Habilitar os recursos em um agendamento

Para obter mais informações sobre a biblioteca de Gerenciamento de Recursos do Python, prossiga para o documento a seguir.

Gerenciamento de recursos para Python

Comentários

Esta página foi útil?

Last updated on 2026-06-25