Identificación y eliminación de puntos de conexión de búsqueda de vectores vacíos

En esta página se describe cómo puede identificar y eliminar puntos de conexión de búsqueda vectorial vacíos. Dado que los puntos de conexión de búsqueda vectorial son recursos específicos del área de trabajo, debe repetir este proceso por separado para cada área de trabajo.

Requisitos

SDK de Databricks para Python (databricks-sdk).
SDK de Python de Búsqueda de vectores de Databricks (databricks-vectorsearch).
Autenticación configurada (perfiles de configuración o OAuth, PAT o ).
CAN_MANAGE permiso para los puntos de conexión de búsqueda vectorial en áreas de trabajo de destino.

Para instalar los SDK necesarios en el cuaderno de Databricks o en el entorno local de Python:

# In a Databricks notebook
%pip install databricks-sdk databricks-vectorsearch

# In local Python environment
# pip install databricks-sdk databricks-vectorsearch

Identificación de puntos de conexión vacíos

En la interfaz de usuario de Databricks, los puntos de conexión de búsqueda vectorial se muestran en la pestaña Búsqueda de vectores de la pantalla Proceso . Active la casilla Puntos de conexión vacíos para mostrar los puntos de conexión que no tienen índices asociados. Los puntos de conexión vacíos también se marcan con un icono de triángulo de advertencia como se muestra.

Autenticación

En esta sección se describen las opciones de autenticación.

Opción 1. Ejecución dentro de un cuaderno de Databricks

Al ejecutar el código en un cuaderno del área de trabajo de Databricks, la autenticación es automática:

from databricks.vector_search.client import VectorSearchClient

# Credentials are picked up automatically from notebook context
client = VectorSearchClient()

Opción 2. Un token de acceso personal (PAT)

Para entornos externos, proporcione credenciales explícitas:

from databricks.vector_search.client import VectorSearchClient

client = VectorSearchClient(
    workspace_url="https://<your-instance>.cloud.databricks.com",
    personal_access_token="dapiXXXXXXXXXXXXXXXXXXXXXXXX"
)

Opción 3. Uso de perfiles de configuración (recomendados para varias áreas de trabajo)

Cree un .databrickscfg archivo en el directorio principal e incluya un perfil para cada área de trabajo:

[DEFAULT]
host = https://workspace1.cloud.databricks.com
token = dapiXXXXXXXXXXXXXXXXXXXXXXXX

[PRODUCTION]
host = https://workspace2.cloud.databricks.com
token = dapiYYYYYYYYYYYYYYYYYYYYYYYY

[DEVELOPMENT]
host = https://workspace3.cloud.databricks.com
token = dapiZZZZZZZZZZZZZZZZZZZZZZZZ

Si prefiere no usar perfiles de configuración, puede especificar las credenciales directamente:

# Define workspaces with explicit credentials
workspace_configs = [
    {
        'workspace_url': 'https://workspace1.cloud.databricks.com',
        'token': 'dapiXXXXXXXXXXXXXXXXXXXXXXXX'
    },
    {
        'workspace_url': 'https://workspace2.cloud.databricks.com',
        'token': 'dapiYYYYYYYYYYYYYYYYYYYYYYYY'
    }
]

# Run cleanup, set `dry_run=False` to perform actual deletion
results = cleanup_multiple_workspaces(workspace_configs, dry_run=True)

Eliminación de puntos de conexión en un único área de trabajo

Los puntos de conexión de búsqueda vectorial son específicos del área de trabajo. Este es un script básico para buscar y eliminar puntos de conexión vacíos en una sola área de trabajo. Para limpiar puntos de conexión vacíos en varias áreas de trabajo, consulte Eliminación de puntos de conexión en varias áreas de trabajo.

Importante

La eliminación de puntos de conexión es irreversible. Use la opción dry_run=True para ver una lista de los puntos de conexión que se eliminarán. Después de confirmar que la lista es correcta, ejecute el script con dry_run=False.

from databricks.vector_search.client import VectorSearchClient

def cleanup_empty_endpoints(client, dry_run=True):
    """
    Find and delete empty Vector Search endpoints.

    Args:
        client: VectorSearchClient instance
        dry_run: If True, only print what would be deleted without actually deleting

    Returns:
        List of deleted endpoint names
    """
    deleted_endpoints = []

    # List all Vector Search endpoints
    endpoints = client.list_endpoints()

    for endpoint in endpoints["endpoints"]:
        # List indexes in this endpoint
        indexes = list(client.list_indexes(name=endpoint["name"])['vector_indexes'])

        if len(indexes) == 0:
            if dry_run:
                print(f"[DRY RUN] Would delete empty endpoint: '{endpoint["name"]}'")
            else:
                print(f"Deleting empty endpoint: '{endpoint["name"]}'")
                try:
                    client.delete_endpoint(endpoint["name"])
                    deleted_endpoints.append(endpoint["name"])
                    print(f"✓ Successfully deleted: {endpoint["name"]}")
                except Exception as e:
                    print(f"✗ Failed to delete {endpoint["name"]}: {str(e)}")
        else:
            print(f"Endpoint '{endpoint["name"]}' has {len(indexes)} indexes - keeping")

    return deleted_endpoints

# Example usage
client = VectorSearchClient()  # Uses default authentication
# Set `dry_run=False` when you are ready to delete endpoints
deleted = cleanup_empty_endpoints(client, dry_run=True)
print(f"\nTotal endpoints deleted: {len(deleted)}")

Eliminación de puntos de conexión en varias áreas de trabajo

Para limpiar puntos de conexión vacíos en varias áreas de trabajo, recorra en iteración los perfiles de configuración:

Importante

La eliminación de puntos de conexión es irreversible. Use la opción dry_run=True para ver una lista de los puntos de conexión que se eliminarán. Después de confirmar que la lista es correcta, ejecute el script con dry_run=False.

Al procesar muchas áreas de trabajo, tenga en cuenta los límites de velocidad de API. Agregue retrasos si es necesario:

import time

for config in workspace_configs:
    # Set `dry_run=False` to perform actual deletion
    result = cleanup_workspace(**config, dry_run=True)
    time.sleep(2)  # Add delay between workspaces

from databricks.sdk import WorkspaceClient
from databricks.vector_search.client import VectorSearchClient
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def cleanup_workspace(profile_name=None, workspace_url=None, token=None, dry_run=True):
    """
    Clean up empty endpoints in a specific workspace.

    Args:
        profile_name: Name of configuration profile to use
        workspace_url: Direct workspace URL (if not using profile)
        token: PAT token (if not using profile)
        dry_run: If True, only show what would be deleted

    Returns:
        Dict with cleanup results
    """
    try:
        # Initialize client based on authentication method
        if profile_name:
            # Use Databricks SDK to get credentials from profile
            w = WorkspaceClient(profile=profile_name)
            workspace_url = w.config.host
            client = VectorSearchClient(
                workspace_url=workspace_url,
                personal_access_token=w.config.token
            )
            logger.info(f"Connected to workspace using profile '{profile_name}': {workspace_url}")
        elif workspace_url and token:
            client = VectorSearchClient(
                workspace_url=workspace_url,
                personal_access_token=token
            )
            logger.info(f"Connected to workspace: {workspace_url}")
        else:
            # Use default authentication (notebook context)
            client = VectorSearchClient()
            logger.info("Connected using default authentication")

        # Perform cleanup
        deleted = cleanup_empty_endpoints(client, dry_run=dry_run)

        return {
            'workspace': workspace_url or 'default',
            'success': True,
            'deleted_count': len(deleted),
            'deleted_endpoints': deleted
        }

    except Exception as e:
        logger.error(f"Failed to process workspace: {str(e)}")
        return {
            'workspace': workspace_url or profile_name or 'default',
            'success': False,
            'error': str(e)
        }

def cleanup_multiple_workspaces(workspace_configs, dry_run=True):
    """
    Clean up empty endpoints across multiple workspaces.

    Args:
        workspace_configs: List of workspace configurations
        dry_run: If True, only show what would be deleted

    Returns:
        Summary of cleanup results
    """
    results = []

    for config in workspace_configs:
        logger.info(f"\n{'='*60}")
        result = cleanup_workspace(**config, dry_run=dry_run)
        results.append(result)
        logger.info(f"{'='*60}\n")

    # Print summary
    total_deleted = sum(r['deleted_count'] for r in results if r['success'])
    successful = sum(1 for r in results if r['success'])
    failed = sum(1 for r in results if not r['success'])

    logger.info("\n" + "="*60)
    logger.info("CLEANUP SUMMARY")
    logger.info("="*60)
    logger.info(f"Workspaces processed: {len(results)}")
    logger.info(f"Successful: {successful}")
    logger.info(f"Failed: {failed}")
    logger.info(f"Total endpoints deleted: {total_deleted}")

    if failed > 0:
        logger.warning("\nFailed workspaces:")
        for r in results:
            if not r['success']:
                logger.warning(f"  - {r['workspace']}: {r['error']}")

    return results

# Example: Clean up using configuration profiles
workspace_configs = [
    {'profile_name': 'DEFAULT'},
    {'profile_name': 'PRODUCTION'},
    {'profile_name': 'DEVELOPMENT'}
]

# Set `dry_run=False` to do actual deletion.
results = cleanup_multiple_workspaces(workspace_configs, dry_run=True)

Filtrado personalizado

Puede agregar lógica personalizada para excluir determinados puntos de conexión de la eliminación, como se muestra a continuación:

def should_delete_endpoint(endpoint, indexes):
    """
    Custom logic to determine if an endpoint should be deleted.

    Args:
        endpoint: Endpoint object
        indexes: List of indexes in the endpoint

    Returns:
        Boolean indicating if endpoint should be deleted
    """
    # Don't delete if it has indexes
    if len(indexes) > 0:
        return False

    # Don't delete endpoints with specific naming patterns
    protected_patterns = ['prod-', 'critical-', 'do-not-delete']
    for pattern in protected_patterns:
        if pattern in endpoint.name.lower():
            logger.warning(f"Skipping protected endpoint: {endpoint.name}")
            return False

    # Add more custom logic as needed
    return True

Exportar resultados

Para guardar los resultados de la limpieza en un archivo para la auditoría:

import json
from datetime import datetime

def export_results(results, filename=None):
    """Export cleanup results to JSON file."""
    if not filename:
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f'vector_search_cleanup_{timestamp}.json'

    with open(filename, 'w') as f:
        json.dump({
            'timestamp': datetime.now().isoformat(),
            'results': results
        }, f, indent=2)

    logger.info(f"Results exported to: {filename}")

Solución de problemas

Problemas de autenticación.

Compruebe que los tokens pat son válidos y no han expirado.
Asegúrese de que los perfiles de configuración tienen el formato correcto.
Compruebe que los tokens tienen los permisos necesarios.

Errores de permisos

Compruebe que el usuario o la entidad de servicio tienen CAN_MANAGE permiso para los puntos de conexión de Búsqueda vectorial.

Problemas de red

Para entornos con requisitos de proxy, configure el SDK correctamente:

import os
os.environ['HTTPS_PROXY'] = 'http://your-proxy:po

Pasos siguientes

Programe este script para que se ejecute periódicamente mediante trabajos de Lakeflow.
Integración con la canalización de infraestructura como código.
Agregue notificaciones por correo electrónico o Slack para resúmenes de limpieza.
Cree un panel para realizar un seguimiento del uso del punto de conexión entre áreas de trabajo.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-11-15