Posts Tagged - key-vault

Store and organize secrets, keys and certificates (Key Vault)

Azure Key Vault es un servicio administrado para centralizar, almacenar y proteger información sensible, especialmente secretos, contraseñas, claves criptográficas y certificados, evitando hardcodearlos en código, repos o archivos de config.

Permite que las apps de Azure accedan de forma controlada a estos valores mediante Entra ID y Managed Identities (RBAC)

Azure Key Vault tiene 3 core capabilities:

  • Secrets management
  • Key management
  • certificate management

En todos los casos los objetos se encriptan at rest y se controla el acceso con Entra ID y RBAC

Opera en 2 tiers:

  • Standard tier: encripta keys usando libraries validadas con FIPS 140 lvl 1. Es suficiente para apps donde software-protected keys es suficiente
  • Premium tier: encripta keys usando FIPS 140-3 lvl 3 y tiene el validacion Hardware Security Modules (HSM). Se usa para cuando tienes regulatory requirements o requerimientos de compliance para HSM-protected Keys

Choose the right object type for your credentials

Secrets

Almacena string values arbitrarios hasta 25 KB - se usa para API keys, connection strings, pwd y tokens

Key Vault trata los secretos como byte sequences opacas y no fuerza ningún tipo de estructura

# Code fragment - focus on setting a secret with content_type
client.set_secret(
    "openai-api-key",
    "sk-abc123def456",
    content_type="text/plain",
    tags={"environment": "production", "team": "ai-platform"}
)

Keys

Alacena keys criptográficas para encriptar y firmar.

Key Vault ejecuta operaciones criptograficas server-side para que el material nunca abandone el limite del vault.

Lo usan AI apps que encriptan o firman datos ya que tienes mas garantias de que estos nunca se exponen ni abandonan los boundaries, comaprado vs almacenarlos en local

Certificates

Alacenan certificados junto a sus claves privadas.

Key Vault se encarga del lifecycle de los certificados con la gestión de renovar, revocar, etc.

Cuando Key Vault almacena un certificado, crea una key correspondiente y un secreto al que puedes acceder

Organize vaults and objects for AI solutions

IMPORTANTE

Vault-per-app boundary: Puedes crear vaults separadas para cada app y environment combination. Así podemos tener kv-ragpipe-dev, kv-ragpipe-staging y kv-ragpipe-prod.

Esta separación limita el daño en caso de accidente de seguridad. Una vault comprometida solo afecta a los secretos de una aplicación para un environment.

Vault-per-app boundaries también simplifica RBAC assignment porque puedes dar acceso a un equipo para DEV sin exponer las credenciales de PROD

Naming conventions: Puedes usar nombres descriptivos con guiones para encodear el resource type y el propósito cosmosdb-connection-string, openai-api-key o blob-storage-account-key.

Las vaults deben tener nombres globalmente únicos dentro de Azure.

Tags for metadata: Puedes poner tags a secretos para filtrar y administrar. Cada secreto soporta hasta 15 tags. environment=prod, team=ai-platform, rotation-policy=90-days.

IMPORTANTE

Control access with RBAC

Key Vault soporta dos modos de auth: RBAC y legacy access policies.

RBAC es el approach recomendado por su granularidad de control a nivel de Azure resource level y soporte.

Key Vault ofrece distintos data plane roles para secret management:

  • Key Vault Secrets User: Da read-only access a secret values, incluyendo poder leer private keys de certificados, que están guardadas como secretos
  • Key Vault Secrets Officer: Full management permissions a secretos (CRUD). Se asigna a operators o CI/CD pipes responsables del lifecycle management
  • Key Vault Administrator: All data plane ops sobre keys, secretos y certificados. No da control sobre el management del vault resource en si mismo o para modificar roles
  • Key Vault Reader: Da read access al vault metadata (secret names y properties) sin revelar el contenido de los secretos o las keys. Es util para monitoring y discovery tools que necesitan verificar que secretos existen sin acceder a su contenido.

IMPORTANTE

Puedes usar managed identities para app-to-vault auth. Una managed identity elimina la necesidad de guardar cualquier credencial en tu app code o conf. La app autentica contra Key Vault usando Entra ID, y RBAC determina que operaciones puede ejecutar esa identidad.

De esta forma necesitas almacenar 0 credenciales para acceder al vault, el cual contiene todo el resto de credenciales.

El rol Key Vault Contributor es un rol del control plane solo. Da permiso para hacer management del vault resource (CRUD) pero no da acceso al data plane como leer secretos, keys o certs. Usar siempre los roles del data plane para acceso a secretos

/IMPORTANTE

Protect against accidental deletion with soft delete and purge protection

Key Vault permite soft delete by default y no se puede desactivar una vez se activa. (valor por defecto de retencion = 90 dias).

Purge protection es una feature opcional que previene permanent deletion de soft-deleted objects durante el retention period. Cuando se activa esta protección NADIE puede borrar de manera permanente un secreto hasta que el periodo de retencion termina.

Read More

Handle secret versioning and rotation (Key Vault)

Cada vez que guardas un secreto con el mismo nombre en Key Vault, el vault crea una nueva versión, en vez de sobreescribir la existente. Esto es fundamental para soportar credential rotation porque permite que las credenciales nuevas y viejas coexistan durante el período de transición.

Understand how Key Vault versions secrets

Cada llamada a set_secret() con el mismo secret name crea una nueva version y le asigna un GUID unico. Llamar a get_secret() sin version param siempre devuelve la ultima version. También puedes llamar a get_secret() con una version especifica. Las versiones previas se mantienen accesibles hasta que las borras o desactivas de manera explicita.

# Code fragment - focus on creating a new version and retrieving by version ID
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient

credential = DefaultAzureCredential()
client = SecretClient(
    vault_url="https://kv-ragpipeline-prod.vault.azure.net/",
    credential=credential
)

# Create initial version
initial = client.set_secret("cosmosdb-connection-string", "AccountEndpoint=https://...")
print(f"Version 1: {initial.properties.version}")

# Create new version with updated value
updated = client.set_secret("cosmosdb-connection-string", "AccountEndpoint=https://new...")
print(f"Version 2: {updated.properties.version}")

# Retrieve latest version (returns version 2)
latest = client.get_secret("cosmosdb-connection-string")

# Retrieve specific version (returns version 1)
specific = client.get_secret("cosmosdb-connection-string",
                              version=initial.properties.version)

Como por defecto get_secret() obtiene la ultima version, tu app no tiene que saber que version usa. De esta manera con guardar una nueva version, esta ya se propaga por la app.

Los IDs son utiles para auditorias.

List and inspect secret versions

El metodo list_properties_of_secret_versions() enumera todas las versiones de un secreto especifico. Cada version incluye ID, fechas y status. Se usa para auditar rotacion.

# Code fragment - focus on listing and inspecting secret versions
versions = client.list_properties_of_secret_versions("cosmosdb-connection-string")

for version in versions:
    print(f"Version: {version.version}")
    print(f"  Created: {version.created_on}")
    print(f"  Enabled: {version.enabled}")
    print(f"  Expires: {version.expires_on}")

Tras una rotacion podemos considerar desactivar versiones previas para forzar a que la app use la nueva version. Esto lo podemos hacer llamando a update_secret_properties() con enabled=False, lo cual previene que la versión se obtenga.

Choose rotation strategy

Manual rotation

Método más simple. Creamos una nueva version en Key Vault y reiniciamos la app.

Es util para cambios infrecuentes, pero hay una ventana entre que actualizamos el secreto y la app sigue usando el viejo.

Automated Rotation with Event Grid

Key Vault se integra con Azure Event Grid para emitir eventos cuando los secretos se aproximan a su expiration date.

El evento SecretNearExpiry se lanza 30 dias antes de que expire.
El evento SecretExpired se lanza cuando ya ha expirado.

Una Azure Function u otro handler se encarga de escuchar esos eventos, genera una nueva credencial, guarda el nuevo valor y la nueva version en el Key Vault.

Esto lo automatiza enteramente el lifecycle. Resumen:

  1. Key Vault emite SecretNearExpiry event
  2. Event Grid entrega el evento al handler registrado
  3. Una Azure Function recibe el evento
  4. La function genera una nueva credencial para el target service
  5. La function guarda la nueva credencial como una nueva secret verison en el key vault

Dual-credential rotation

Para servicios que soportan dos keys activas de manera simultanea, como Storage accounts y CosmosDB.

  1. Generamos una nueva key secundaria en el target service
  2. Guardamos la nueva key como una nueva secret version en el Key Vault
  3. Esperamos a que todas las aplicaciones pillen el nuevo valor
  4. Regeneramos la vieja primary key en el target service

De esta manera garantizamos que al menos hay una credencial valida que exista siempre.

Implement zero-downtime rotation in app code

Independientemente de la estrategia seleccionada, el codigo de la app debe encargarse de la transicion entre secreto viejo y nuevo.

El patron recomendado atrapa fallos de downstream services, hace refetch del secreto desde la Key Vault y reintenta la operacion con la nueva credencial. De esta manera evitamos restarts y soportamos rotacion.

# Code fragment - focus on retry-on-auth-failure pattern for rotation
from azure.core.exceptions import HttpResponseError

def call_downstream_service(client, secret_name, max_retries=1):
    """Retrieve secret and call service, refreshing on auth failure."""
    secret_value = client.get_secret(secret_name).value

    for attempt in range(max_retries + 1):
        try:
            # Use secret_value to authenticate with downstream service
            result = connect_to_service(secret_value)
            return result
        except AuthenticationError:
            if attempt < max_retries:
                # Credential might be rotated - refresh from Key Vault
                secret_value = client.get_secret(secret_name).value
            else:
                raise

Este patron limita la performance del impacto de rotacion cuando la primera auth falla.

Set expiration dates on secrets

IMPORTANTE

La property expires_on define la expiration date. Los secretos expirados todavia existen en el key vault y se pueden obtener a través de get_secret(). La expiracion es informativo, más que un hard limit. En si misma es para indicar que se deberia de cambiar.

/IMPORTANTE

Read More

Retrieve secrets using Azure SDK client libraries (Key Vault)

La python library azure-keyvault-secrets proviene la clase SecretClient para todas las operaciones de secretos contra Azure Key Vault. Combinado con azure-identity para auth, ambos paquetes cubren la necesidad de obtener credenciales en codigo.

Install the SDK

El Key Vault secrets SDK requiere de dos packages

  • azure-keyvault-secrets para vault ops
  • azure-identity para auth
pip install azure-keyvault-secrets azure-identity

La URL de la vault sigue el patron https://<vault-name>.vault.azure.net/

la url se puede obtener desde la web o asi

az keyvault show --name <vault-name> --query properties.vaultUri

Authenticate with DefaultAzureCredential

DefaultAzureCredential de la libreria azure-identity encadena multiples auth methods en un orden definido, provando cada uno hasta que uno funciona. Esta clase funciona para desarrollo local y PROD sin cambios de codigo.

En produccion, managed identity se autentica sin credenciales almacenadas. En local, lo hace a través de Azure CLI.

Orden que sigue:

  1. EnvironmentCredentials: Lee AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET environment vars
  2. WorkloadIdentityCredential: Auth usando K8s workload identity tokens
  3. ManagedIdentityCredential: Usa Azure managed identity (system-assigned o user-assigned) attached al computer resource
  4. AzureCliCredential: Auth usando az login
  5. AzureDeveloperCliCredential: Auth usando azd auth login
  6. AzurePowerShellCredential: Auth usando Connect-AzAccount

Para servicios que corren en Azure compute resources (Container Apps, K8s o App Service) se recomienda usar managed identity como auth method. La app hace auth a Key Vault a través de Entra ID.
La managed identity necesita el rol Key Vault Secrets User.

Retrieve a secret by name

El metodo get_secret() obtiene la version actual de un secreto de la Key Vault.
El object obtenido KeyVaultSecret contiene secret value, name y properties con metadatos como la version o fechas.

# Code fragment - focus on retrieving a secret with DefaultAzureCredential
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient

credential = DefaultAzureCredential()
client = SecretClient(
    vault_url="https://kv-ragpipeline-prod.vault.azure.net/",
    credential=credential
)

secret = client.get_secret("openai-api-key")

# Access the secret value and metadata
api_key = secret.value
version = secret.properties.version
created = secret.properties.created_on
content_type = secret.properties.content_type

El secret.value contiene la secret string que tu app pasa a downstream service clients. Los properties son metadata para logging o debugging.

List secret properties

El metodo list_properties_of_secrets() enumera todos los secretos del vault - SIN OBTENER SUS VALORES.
Esto devuelve SecretProperties que contiene metadata. Se usa para hacer discovery de los secretos disponibles.

# Code fragment - focus on listing secret properties for discovery
secret_properties = client.list_properties_of_secrets()

for prop in secret_properties:
    print(f"Secret: {prop.name}, Enabled: {prop.enabled}, "
          f"Content type: {prop.content_type}")
    if prop.tags:
        print(f"  Tags: {prop.tags}")

El listado es util durante app startup para validar que todas las credenciales existen.

Handle errors and exceptions

El SDK levanta excepciones especificas para distintos escenarios. Es nuestra responsabilidad gestionarlos bien para ver cual es recuperable y cual no.

# Code fragment - focus on structured error handling for secret retrieval
from azure.core.exceptions import (
    ResourceNotFoundError,
    HttpResponseError,
    ServiceRequestError
)

def get_secret_safely(client, secret_name):
    try:
        secret = client.get_secret(secret_name)
        return secret.value
    except ResourceNotFoundError:
        # Secret doesn't exist - configuration error
        print(f"Secret '{secret_name}' not found in vault. "
              "Verify the secret name and vault configuration.")
        raise
    except HttpResponseError as e:
        # Authentication or authorization failure
        print(f"Access denied or server error for '{secret_name}': "
              f"{e.status_code} - {e.message}")
        raise
    except ServiceRequestError:
        # Network connectivity issue - may be transient
        print(f"Network error retrieving '{secret_name}'. "
              "Check connectivity to Key Vault.")
        raise

Use the async client for high-throughput apps

El modulo azure.keyvault.secrets.aio provee un SecretClient async para apps que usan asyncio. Los servicios de IA que procesan requests concurrentes se benefician de async secret retrieval porque evita bloquear el event loop durante vault calls.

# Code fragment - focus on async secret retrieval
from azure.identity.aio import DefaultAzureCredential
from azure.keyvault.secrets.aio import SecretClient

async def get_ai_credentials():
    credential = DefaultAzureCredential()
    client = SecretClient(
        vault_url="https://kv-ragpipeline-prod.vault.azure.net/",
        credential=credential
    )

    async with client:
        secret = await client.get_secret("openai-api-key")

    await credential.close()
    return secret.value

Read More

Implement caching strategies (Key Vault)

Understand Key Vault throttling limits

Key Vault tiene throttling limits para proteger el servicio. Cuando esto pasa se devuelve HTTP 429 (Too Many Requests).

Para secretos, Key Vault soporta hasta 4000 GET per vault en 10s.
Los write se llevan a un limite de 300 colectivo en 10 segundos.

Son limites grandes pero que se pueden alcanzar rápidamente si una app llama get_secret() con cada input request. Esto lo solucionamos mediante caching.

Implement a time-based in-memory cache

El método más simple es guardar el secreto en memoria con un TTL. Esto se puede usar para secretos que cambian infrecuentemente. Una ventana de 15-60 mins es aceptable.

# Code fragment - focus on time-based caching pattern
import time
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient

class SecretCache:
    def __init__(self, vault_url, cache_ttl_seconds=900):
        credential = DefaultAzureCredential()
        self._client = SecretClient(vault_url=vault_url, credential=credential)
        self._cache = {}
        self._cache_ttl = cache_ttl_seconds

    def get_secret(self, secret_name):
        cached = self._cache.get(secret_name)
        now = time.monotonic()

        if cached and (now - cached["timestamp"]) < self._cache_ttl:
            return cached["value"]

        secret = self._client.get_secret(secret_name)
        self._cache[secret_name] = {
            "value": secret.value,
            "timestamp": now
        }
        return secret.value

El param cache_ttl_seconds controla el tiempo en segundos.

Invalidar la cache con Azure Event Grid

Time-based caching introduce una ventana de tiempo donde la app puede usar la vieja credencial tras una rotacion.

Para ventanas más ajustadas podemos suscribirnos al evento del Key Vault SecretNewVersionCreated a través de Azure Event Grid. Cuando se crea una nueva version se lanza este evento.

Entonces invalidamos la cache local y obtenemos el nuevo.

Este métodos es útil porque la cache solo se recarga cuando realmente hay un cambio, en vez de en un timer fijo.

Choose the right cache scope

El scope de tu cache determina cuantas llamadas a Key Vault hace tu app de manera colectiva.

Per-process cache

Método más simple. Cada app instance mantiene su propia in-memory cache. Funciona muy bien para stateless services donde cada instancia gestiona de manera independiente las caches de secretos.

Shared distributed cache

Usamos un external store como Managed Redis como capa intermedia entre la app y el key vault. Un único proceso lee el secreto del Key Vault y lo escribe en la cache compartida. El resto de instancias leen de la cache.

Añade complejidad e introduce dependencias de la cache compartida. Tambien almacenamos los secretos en un store independiente fuera del Key Vault (la cache), lo cual requiere su propio control de acceso y encriptación.

Application startup preloading

Obtenemos todos los secretos en startup y los guardamos en memoria por el lifetime del proceso. Funciona muy bien para servicios contenerizados donde las instancias se reinician periodicamente, y para secretos que raramente cambian.

# Code fragment - focus on startup preloading pattern
class AppConfig:
    def __init__(self, vault_url, secret_names):
        credential = DefaultAzureCredential()
        client = SecretClient(vault_url=vault_url, credential=credential)

        self._secrets = {}
        for name in secret_names:
            secret = client.get_secret(name)
            self._secrets[name] = secret.value

    def get(self, secret_name):
        return self._secrets.get(secret_name)

# At application startup
config = AppConfig(
    vault_url="https://kv-ragpipeline-prod.vault.azure.net/",
    secret_names=["openai-api-key", "cosmosdb-connection-string",
                  "blob-storage-key"]
)

# During request processing - no vault calls
api_key = config.get("openai-api-key")

Balance cache lifetime with security requirements

El cache lifetime que decidamos depende de la frecuencia de rotacion y la ventana de tiempo que sea aceptable tener secretos caducados hasta que se renueven.

Para keys que rotan cada 90 dias, hasta 1h de TTL es aceptable.

Para keys que son criticas lo mejor es poner un TTL de 5 mins o usar event-driven invalidation a través de Event Grid.

  • High-rotation secrets (daily/weekly): 5-15 mins TTL combinado con Event Grid
  • Standard (monthly/quarterly): 30-60 min TTL. Event Grid es beneficioso pero no critico
  • Low-rotation (annual/static): Startup preloading with periodic refresh (every few hours)

Handle throttling gracefully

Cuando tu app recibe HTTP 429 como respuesta del Key Vault, implementamos exponential backoff antes de reintentar

# Code fragment - focus on logging throttling events for cache tuning
import logging

logger = logging.getLogger("keyvault")

def get_secret_with_monitoring(cache, secret_name):
    try:
        return cache.get_secret(secret_name)
    except HttpResponseError as e:
        if e.status_code == 429:
            logger.warning(
                "Key Vault throttled request for '%s'. "
                "Consider increasing cache TTL.", secret_name
            )
        raise

Read More