CONECTAR AZURE DATABRICKS CON AZURE AI FOUNDRY DE FORMA SEGURA

Hola a todos!

Hace unos días os compartí este post: De Power Platform a Azure Databricks: escalando el análisis con Python y Azure Foundry

En él hablaba de cómo llevar un proceso de análisis desde Power Platform hacia una arquitectura más escalable con Azure Databricks, Python y Azure AI Foundry.

Hoy quiero centrarme en una parte muy concreta, pero fundamental: el primer bloque del código en Databricks, donde preparamos la conexión segura con el modelo desplegado en Azure AI Foundry / Azure OpenAI.

Antes de procesar registros, construir lotes o guardar resultados, hay que resolver bien una cuestión básica: cómo conectamos Databricks con Foundry sin dejar claves sensibles escritas directamente en el notebook?

La idea es utilizar Azure Key Vault como almacén seguro de secretos y acceder a ellos desde Databricks mediante un secret scope.

De esta forma, el notebook no contiene la API Key ni el endpoint en claro, pero sí puede recuperarlos en tiempo de ejecución para realizar la llamada al modelo.

import requests
import json
import time
from datetime import datetime

# Secret scope vinculado a Azure Key Vault
secret_scope = "kv-excelsignum-dev"

# Credenciales y endpoint recuperados desde Key Vault
api_key = dbutils.secrets.get(scope=secret_scope, key="azure-foundry-api-key")
endpoint = dbutils.secrets.get(scope=secret_scope, key="azure-foundry-endpoint-gpt5-chat")

# Configuración de la llamada HTTP al modelo
headers = {
    "Content-Type": "application/json",
    "api-key": api_key
}

# Tabla origen con los registros a analizar
tabla_origen = "dbw_excelsignum_analytics_dev.default.empleados_raw"

# Tabla donde se guardan las respuestas correctas de la IA
tabla_log = "dbw_excelsignum_analytics_dev.default.empleados_resultados_ia_log"

# Tabla donde se registran los errores del proceso
tabla_errores = "dbw_excelsignum_analytics_dev.default.empleados_errores_ia"

# Número de registros enviados en cada llamada al modelo
tamano_lote = 10

# Límite de registros para esta prueba
limite_registros = 100

1 – Importamos las librerías necesarias:

import requests
import json
import time
from datetime import datetime

En este primer bloque importamos las librerías que vamos a necesitar para trabajar con la llamada al modelo.

requests: nos permitirá hacer peticiones HTTP al endpoint de Azure AI Foundry.
json: nos servirá para construir y leer estructuras de datos en formato JSON.
time: nos ayudará más adelante si queremos controlar pausas, esperas o reintentos.
datetime: nos permitirá registrar fechas y horas durante el proceso, por ejemplo, para guardar cuándo se ha ejecutado una llamada o cuándo se ha producido un error.

2 – Definimos el secret scope de Databricks:

secret_scope = "kv-excelsignum-dev"

Aquí indicamos el nombre del secret scope que Databricks utilizará para acceder a los secretos.

Este secret scope está vinculado a Azure Key Vault.

La idea es que las credenciales sensibles no estén escritas en el notebook. En su lugar, Databricks las recupera desde Key Vault cuando se ejecuta el código.

3 – Recuperamos la clave de Azure Foundry:

api_key = dbutils.secrets.get(scope=secret_scope, key="azure-foundry-api-key")

Con esta línea recuperamos la clave del recurso de Azure Foundry. Esto permite mantener el código más limpio y, sobre todo, más seguro.

4 – Recuperamos el endpoint del modelo:

endpoint = dbutils.secrets.get(scope=secret_scope, key="azure-foundry-endpoint-gpt5-chat")

En esta línea recuperamos el endpoint del modelo desplegado en Azure AI Foundry.

Este endpoint es la dirección a la que Databricks enviará las peticiones.

También lo guardamos en Key Vault para evitar tenerlo escrito directamente en el notebook. Aunque el endpoint no siempre es tan sensible como una clave, mantenerlo fuera del código ayuda a separar mejor la configuración de la lógica.

5 – Preparamos las cabeceras de la llamada:

headers = {
    "Content-Type": "application/json",
    "api-key": api_key
}

Aquí configuramos las cabeceras que se enviarán en la petición HTTP.
Content-Type: indica que vamos a enviar información en formato JSON.
api-key: incluye la clave recuperada desde Key Vault.

Esta estructura se utilizará más adelante cuando hagamos la llamada al modelo con requests.post().

6– Definimos las tablas del proceso:

tabla_origen = "dbw_excelsignum_analytics_dev.default.empleados_raw"
tabla_log = "dbw_excelsignum_analytics_dev.default.empleados_resultados_ia_log"
tabla_errores = "dbw_excelsignum_analytics_dev.default.empleados_errores_ia"

En este bloque indicamos las tablas que va a utilizar el proceso.
La primera es la tabla origen, donde están los registros que queremos analizar.
La segunda es la tabla de log, donde guardaremos las respuestas correctas devueltas por la IA.
La tercera es la tabla de errores, donde registraremos cualquier problema que pueda aparecer durante la ejecución.

Esto es importante porque, cuando trabajamos con IA aplicada a datos, no basta con obtener una respuesta del modelo. También necesitamos trazabilidad: saber qué se ha procesado, qué ha respondido la IA y qué errores se han producido.

7 – Definimos los parámetros básicos de ejecución:

tamano_lote = 10
limite_registros = 100

Aquí configuramos dos parámetros sencillos, pero muy útiles.

tamano_lote indica cuántos registros enviaremos en cada llamada al modelo. En este caso, cada lote tendrá 10 registros.

limite_registros permite limitar la ejecución inicial a 100 registros. Esto es especialmente útil durante las pruebas, porque nos permite validar la conexión, el formato de respuesta y el guardado de resultados antes de lanzar el proceso sobre un volumen mayor.

Y esto es todo. Espero que os sirva como ejemplo para poder realizar la conexión de Azure Databricks con Azure Foundry