Posts Tagged - az-app-configuration

App Configuration vs Key Vault (what to store)

App Configuration y Key Vault sirven roles complementarios en administrar settings para apps.

Azure App Configuration

Está diseñado para app settings, en pares clave-valor, y que sean no sensibles.

Características

  • labels para diferenciar entornos
  • feature flag management
  • rollbacks
  • dynamic refresh

Esto incluye

  • endpoints
  • feature flags
  • batch sizes
  • rerty counts
  • timeout values
  • display strings

Azure Key Vault

Está diseñado para datos sensibles.

Características

  • Encripta los datos at rest con HSM-backed protection
  • loggea cada op y se puede auditar
  • fuerza expiration policies
  • automated rotation
  • provee soft-delete con purge protection

Esto incluye

  • API keys
  • connection strings
  • passwords
  • keys criptograficas
  • certificados

Ejemplos

Setting type Service Example
Configuracion nonsensitive App Configuration (direct value) OpenAI:Endpoint
Feature toggles App Configuration (feature flag) EnableBatchProcessing
API keys and tokens Key Vault (via App Configuration reference) OpenAI:ApiKey
Connection strings Key Vault (via App Configuration reference) CosmosDB:ConnectionString
Certificates Key Vault (direct access) TLS certificates for HTTPS

Anti-patterns

  • Storing secrets directly in App Configuration: always use Key Vault references for values that grant access to resources
  • Using Key Vault for non-sensitive settings
  • Duplicating settings across both services without references
  • Embedding all configuration in application code

Read More

Reference Key Vault secrets (App Configuration)

Understand Key Vault references

Una Key Vault reference es un par especial clave-valor en App Configuration, donde el valor contiene una URI que apunta a un secreto en Key Vault

El content type es especial application/vnd.microsoft.appconfig.keyvaultref+json;charset=utf-8. El provider resuelve la referencia automáticamente, por lo que la app nunca llega a ver este valor. Solo ve una variable de entorno como cualquier otra.

No hay que escribir código custom, la app nunca ve diferencia o los entresijos por detrás

La App Configuration no almacena nunca el valor actual del secreto. Solo tiene el puntero donde reside en el Key Vault

Create Key Vault references

Podemos crear referencias desde el Azure Portal o con Azure CLI

az appconfig kv set-keyvault \
	--name myAppConfigStore \
	--key "OpenAI:ApiKey" \
	--secret-identifier "https://my-keyvault.vault.azure.net/secrets/openai-api-key" \
	--label "Production"

El --secret-identifier acepta la full URI y podemos incluir una versión https://my-keyvault.vault.azure.net/secrets/open-api-key/custom-version-1. Si omitimos la versión, por defecto se apunta a latest, y es lo recomendado.

También se pueden aplicar labels a las Key Vault references, por lo que podemos tener varias para separar entornos Production de por ej. Development

Configure python provider for Key Vault resolution

La library azure-appconfiguration-provider resuelve Key Vault references de manera automatica cuando le das una credencial a través del param keyvault_credential. Si pasamos un DefaultAzureCredential que autentica a ambos App Configuration y Key Vault usando la misma managed identity.

# Code fragment - focus on resolving Key Vault references through the provider
from azure.appconfiguration.provider import load
from azure.identity import DefaultAzureCredential
import os

endpoint = os.environ.get("AZURE_APPCONFIG_ENDPOINT")
credential = DefaultAzureCredential()

config = load(
    endpoint=endpoint,
    credential=credential,
    keyvault_credential=credential
)

# Regular settings and resolved Key Vault secrets are accessed the same way
model_endpoint = config["OpenAI:Endpoint"]     # Regular value from App Configuration
api_key = config["OpenAI:ApiKey"]               # Resolved from Key Vault
batch_size = config["Pipeline:BatchSize"]       # Regular value from App Configuration

Set up authentication for both services

La app identity tiene que tener permisos para ambos App Configuration y Key Vault para que las Key Vault references se resuelvan correctamente

Cada servicio usa su propio set de Azure RBAC roles y la identidad necesita por lo menos un rol en cada servicio.

IMPORTANTE

Para App Configuration la identidad necesita el rol App Configuration Data Reader, para obtener settings y referencias.

Para Key Vault la identidad necesita el rol Key Vault Secrets User para leer el secret value al que apunta la referencia.

Si tenemos apps que acceden a secretos de multiples Key Vaults, la identidad necesita el rol Key Vault Secrets User en cada vault referenciada en la configuración

/IMPORTANTE

Understand refresh behavior for Key Vault references

El provider soporta refrescar Key Vault secret values de manera independiente a otros configuration settings, a través del param secret_refresh_interval. Mientras que la Key Vault reference URI en App Configuration se mantiene sin cambiar, el secreto por debajo en Key Vault puede rotar. Este param indica cada cuanto hay que refrescar el secreto.

# Code fragment - focus on configuring independent secret refresh
config = load(
    endpoint=endpoint,
    credential=credential,
    keyvault_credential=credential,
    refresh_on=[WatchKey("Sentinel")],
    refresh_interval=60,
    secret_refresh_interval=7200  # Re-resolve Key Vault secrets every 2 hours
)

Esta separación entre refresh y secret_refresh permite comprobar cambios de config normales, de manera frecuente, y re-resolver los secretos en un ciclo más largo que se alinee con tu periodo de rotacion.

Read More

Azure App Configuration

Azure App Configuration es un servicio administrado, que almacena app settings en pares clave-valor, de forma centralizada en el cloud. Permite modificar configuración dinámicamente y gestionar feature flags, hacer despliegues progresivos o experimentar sin tener que desplegar la app de nuevo.

Understand the App Configuration data model

App Configuration guarda cada setting como pares clave-valor con propiedades adicionales para poder controlar como se identifica, interpreta, y administra la setting.

  • Key: case-sensitive unicode string que identifica la setting. Soporta delimitadores como : o / Ejemplo OpenAI:Endpoint. No se fuerzan schemas sobre las keys
  • Value: unicode string que almacena el dato. El tamaño combinado de Key y Value no puede pasar de 10 KB. Se pueden meter plain strings, JSON obects, o referencias a otros recursos como Key Vault secrets
  • Label: Tag opcional que crea variantes de la misma key. Permite almacenar diferentes valores para la misma key a lo largo de environments, regiones, o versiones.
  • Content Type: Property opcional que indica como se debe interpretar el valor. application/json le dice al provider que parsee el valor como JSON object. Key Vault reference content types le dicen al provider que resuelva el valor de Azure Key Vault
  • Tags: metadatos opcionales en pares clave-valor para filtrar y organizar.

Install the python provider library

La libreria azure-appconfiguration-provider ofrece una interfaz a alto nivel para cargar config settings desde una App Configuration store, a tu python app.
Esta libreria crea un Mapping object que se comporta como un python dict.

Tambien necesitamos la libreria azure-identity para auth

pip install azure-appconfiguration-provider azure-identity

Connect and retrieve settings

La function load() acepta un endpoint parameter para la App Configuration store URL y un credential param para auth. El endpoint sigue el patrón https://<store-name>.azconfig.io

como conectar a App Configuration y hacer get de un valor

# Code fragment - focus on connecting to App Configuration and accessing a setting
from azure.appconfiguration.provider import load
from azure.identity import DefaultAzureCredential
import os

endpoint = os.environ.get("AZURE_APPCONFIG_ENDPOINT")
credential = DefaultAzureCredential()

config = load(endpoint=endpoint, credential=credential)

# Access settings using dictionary syntax
model_endpoint = config["OpenAI:Endpoint"]
batch_size = config["Pipeline:BatchSize"]

Authenticate with DefaultAzureCredential

También se soporta aqui. Prueba diferentes metodos de auth en orden hasta que uno funciona.

Select and filter keys with SettingSelector

La clase SettingSelector filtra que keys carga el provider de la store. Sin un selector, el provider carga cada par clave-valor con null label, lo que puede incluir settings de otras apps que compartan el mismo store.

Puedes usar key_filter para hacer match de keys por prefix o patron (se aceptan wildcards *) y label_filter para seleccionar settings para un entorno o version especifica.

Lo ideal es cargar solo la conf relevante al contexto actual de la app, para reducir memoria y evitar name colisions.

# Code fragment - focus on SettingSelector for filtering keys by prefix and label
from azure.appconfiguration.provider import load, SettingSelector
from azure.identity import DefaultAzureCredential

selects = [
    SettingSelector(key_filter="Pipeline:*", label_filter="Production")
]

config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    selects=selects
)

# Only keys matching "Pipeline:*" with the "Production" label are loaded
batch_size = config["Pipeline:BatchSize"]

Puedes pasar multiples SettingSelector para cargar several groups de settings en una unica llamada. Cuando hay multiples selectores que hacen match de la misma key, el ultimo selector de la lista es el que toma prioridad

Trim key prefixes

Nombres jerarquicos como DocPipeline:OpenAI:Endpoint mantienen la conf store organizada, pero el full prefix es normalmente innecesario dentro del codigo de la app.

El param trim_prefixes borra estos prefijos al cargar la config para que a la app le queden nombres más limpios

# Code fragment - focus on trimming key prefixes for cleaner access
config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    trim_prefixes=["DocPipeline:"]
)

# Access "DocPipeline:OpenAI:Endpoint" as "OpenAI:Endpoint"
model_endpoint = config["OpenAI:Endpoint"]

Trimming es especialmente util cuando hay multiples apps que comparten un config store y cada una usa un prefijo único

Enable dynamic configuration refresh

El provider soporta refresh de config dinámicos para que tu app pueda recibir cambios desde App Configuration sin reiniciarse.

Tienes que activar el refresh especificando uno o más sentinel keys a hacer watch a través del param refresh_on.

Cuando el provider detecta un cambio en esa key que vigilamos, recarga la config entera (para mantener consistencia).
El param refresh_interval controla la frecuencia de ese check (en segundos).

# Code fragment - focus on enabling dynamic refresh with a sentinel key
from azure.appconfiguration.provider import load, WatchKey
from azure.identity import DefaultAzureCredential

config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    refresh_on=[WatchKey("Sentinel")],
    refresh_interval=60
)

# Later in your application loop or request handler
config.refresh()

# Access settings - values reflect the latest from the store after refresh
batch_size = config["Pipeline:BatchSize"]

El patrón sentinel key involucra una key dedicada que hace update cuando quieres que la app recargue su config. Cambiar la sentinel key le indica al provider que hay un nuevo set de config. El métpdp refresh() del provider debe ser llamado de manera explicita. Si el refresh_interval no se ha cumplido desde el ultimo check, la llamada refresh() se ignora y devuelve sin hacer nada.

Read More

Organize settings with labels and feature flags (App Configuration)

Use labels for environment differentiation

Las labels crean variaciones de la misma key para diferentes entornos, regiones o app versions.

Una key como Pipeline:BatchSize puede tener:

  • una label Development con valor 10
  • otra label Staging con valor 50
  • otra label Production con valor 200

El nombre de la key se mantiene igual en todos los entornos, por lo que tu app solo referencia Pipeline:BatchSize independientemente del entorno donde se ejecute.

Keys sin label, realmente usan la label null, representada como \0. Estas sirven como default que aplican cuando no hay otra que la sobreescriba.

Stack key-value pairs with composition

El provider soporta cargar multiples sets de valores clave-valor en secuencia, donde later-loaded values hacen override de los valores previos, para la misma key.

Esto es la base para administrar default settings, junto a environment-specific overrides.
Primero cargas tus valroes default y los valores especificos por environment se cargan on top. Cualquier key que tenga un valor especifico por entorno usa ese override, mientras que las keys que no tengan un override, se quedan como están con sus valores por defecto.

# Code fragment - focus on key-value composition with stacking
from azure.appconfiguration.provider import load, SettingSelector
from azure.identity import DefaultAzureCredential
import os

endpoint = os.environ.get("AZURE_APPCONFIG_ENDPOINT")
environment = os.environ.get("APP_ENVIRONMENT", "Development")

selects = [
    SettingSelector(key_filter="*", label_filter="\0"),
    SettingSelector(key_filter="*", label_filter=environment)
]

config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    selects=selects
)

# Defaults load first, then environment-specific values override matching keys
batch_size = config["Pipeline:BatchSize"]

El orden de SettingSelector importa. El segundo selector hace target de las labels del entorno y hace override de cualquier valor del primer selector.

Design key naming conventions

Una naming convention bien montada simplifica filtrar con SettingSelector. Usamos : o / para agrupar settings relacionadas por service component. Esta estructura permite filtrar por prefijo para cargar solo los settings que necesitamos.

Ejemplos:

  • OpenAI:Endpoint
  • OpenAI:DeploymentName
  • OpenAI:MaxTokens
  • CosmosDB:DatabaseName
  • CosmosDB:ContainerName

Con esta convención un componente que solo necesite OpenAI settings puede cargar keys usando key_filter="OpenAI:*"

Understand Feature Flags in App Configuration

Feature flags son pares especiales clave-valor que la App Configuration administra a través de una interfaz dedicada. Cada feature flag tiene un nombre, status (activado/desactivado) y filtros opcionales que controlan condiciones de activación.

IMPORTANTE

App Configuration almacena los feature feature flags con un key prefix .appconfig.featureflag/ y content type application/vnd.microsoft.appconfig.ff+json;charset-utf-8, pero las librerias se abstraen de todo esto para que solo vean flag names simples y booleanos.

/IMPORTANTE

Las feature flags desacoplan el feature lifecycle del deployment lifecycle. En vez de desplegar nuevo código para activar/desactivar características de nuestra app, podemos hacerlo en runtime con un flag.

Evaluate feature flags with FeatureManager

La libreria featuremanagement integra con el App Configuration provider para evaluar feature flags en runtime.

Cargas feature falgs pasando feature_flags_enabled=True para la function load() del provider, y entonces creas un FeatureManager desde la config cargada. FeatureManager tiene un metodo is_enabled() para comprobar si una feature flag especifica está activa

# Code fragment - focus on loading feature flags and evaluating them
from azure.appconfiguration.provider import load
from azure.identity import DefaultAzureCredential
from featuremanagement import FeatureManager

config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    feature_flags_enabled=True
)

feature_manager = FeatureManager(config)

if feature_manager.is_enabled("UseNewEmbeddingsModel"):
    # Route to the new embeddings model
    process_with_new_model(document)
else:
    # Use the current embeddings model
    process_with_current_model(document)

IMPORTANTE

El FeatureManager evalua el estado del flag cada vez que se llama is_enabled(). Cuando se combina con dynamic refresh, esto hace que la app responda a un cambio de flag sin tener que reiniciar.

/IMPORTANTE

Refresh feature flags dynamically

El dynamic refresh de las Feature flags es independiente del refresh de otras configuration settings

Activas este feature flag refresh mediante feature_flag_refresh_enabled=True pasandoselo a load() function. Un cambio en una feature flag no triggea un refresh de otros config settings.

# Code fragment - focus on enabling dynamic refresh for feature flags
from azure.appconfiguration.provider import load, WatchKey
from azure.identity import DefaultAzureCredential
from featuremanagement import FeatureManager

config = load(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
    feature_flags_enabled=True,
    feature_flag_refresh_enabled=True,
    refresh_on=[WatchKey("Sentinel")],
    refresh_interval=30
)

feature_manager = FeatureManager(config)

# In your application loop or request handler
config.refresh()

# Feature flag state reflects the latest value from the store
if feature_manager.is_enabled("UseNewEmbeddingsModel"):
    process_with_new_model(document)

Apply feature flags

Estas se pueden usar de muchas maneras

  • Progressive model rollouts: activamos nuevos modelos de manera interna a través de una feature flag, pero sin exponerlos a PROD
  • Kill switches: emergency shutoff para un proceso critico
  • A/B testing configurations
  • Staged pipe activation

Read More