# Instrucciones para la migración de MySQL → PostgreSQL ### Introducción {% hint style="warning" %} **¡IMPORTANTE!** SI su versión de AI Server es igual o menor a 2.0.0, entonces en su versión se utilizan MySQL y PostgreSQL 16 simultáneamente. En la nueva versión 2.1.0+ se utiliza solo PostgreSQL 17. {% endhint %} Necesita realizar la migración de MySQL a PostgreSQL, así como migrar los datos de la versión 16 de PostgreSQL a la versión 17. Esta instrucción describe el proceso de migración de la base de datos Sherpa AI Server de MySQL a PostgreSQL. La migración incluye la transferencia de datos, la actualización de configuraciones y la transición a un nuevo sistema de gestión de bases de datos. {% hint style="info" %} **¡ATENCIÓN!** Si tiene la posibilidad de RENUNCIAR A LOS DATOS (SI NO LOS NECESITA), le recomendamos que en lugar de seguir esta instrucción, consulte la guía de instalación desde cero: {% endhint %} {% embed url="" %} ### Requisitos del sistema #### Requisitos mínimos para la migración: * **Espacio libre en disco**: mínimo 2x el tamaño de la base de datos (para datos originales + migración) * **Memoria RAM**: mínimo 4 GB de RAM para pgloader * **Docker**: versión 20.10+ con soporte para Docker Compose * **Conexión de red**: conexión estable a las bases de datos #### Comprobaciones previas Antes de iniciar la migración, realice las siguientes comprobaciones: ```bash # Verifique el espacio disponible en disco df -h # Verifique la memoria RAM disponible free -h # Verifique el estado de Docker docker --version docker compose version # Verifique la disponibilidad de las bases de datos docker ps | grep -E "(mysql|postgres)" ```
💡 Comentarios sobre las comprobaciones **df -h** - muestra el uso del espacio en disco en un formato legible para humanos * Asegúrese de que el espacio libre sea al menos 2 veces mayor que el tamaño de su base de datos **free -h** - muestra información sobre la memoria RAM * Se requieren al menos 4 GB de RAM para pgloader * Si hay insuficiente memoria, la migración puede fallar con el error "Heap exhausted" **docker --version** - verifica la versión de Docker * Se requiere Docker 20.10+ para el correcto funcionamiento de todas las funciones **docker compose version** - verifica la versión de Docker Compose * Asegúrese de que compose soporte la sintaxis moderna **docker ps** - muestra los contenedores en ejecución * Deben ser visibles los contenedores mysql/postgres para acceder a los datos
### Preparación para la migración #### Descarga de archivos necesarios Si el entorno está cerrado, es necesario descargar de antemano los ARCHIVOS PARA LA INSTALACIÓN y además los siguientes archivos: ```bash curl -fSL -OJ https://sherparpa.ru/downloads/private/SherpaAIServer/pgloader_image.tar curl -fSL -OJ https://sherparpa.ru/downloads/private/SherpaAIServer/alpine_image.tar ```
💡 Comentarios sobre la descarga de archivos **curl -fSL -OJ** - descarga archivos desde el servidor * `-f` - finaliza silenciosamente en caso de errores del servidor * `-S` - muestra errores incluso al usar -f * `-L` - sigue redirecciones * `-O` - guarda el archivo con el nombre del servidor * `-J` - utiliza el nombre de archivo proporcionado por el servidor **pgloader\_image.tar** - imagen de Docker con la herramienta pgloader para la transferencia de datos **alpine\_image.tar** - imagen ligera de Linux para operaciones con archivos
Cree un directorio `/opt/SherpaAIServerNew` y coloque en él todos los archivos y ARCHIVOS DE LA INSTRUCCIÓN DE INSTALACIÓN: ```bash # Cree un nuevo directorio para la migración sudo mkdir -p /opt/SherpaAIServerNew # Mueva los archivos descargados al nuevo directorio (y los archivos de la preparación para la descarga) sudo mv pgloader_image.tar /opt/SherpaAIServerNew/ sudo mv alpine_image.tar /opt/SherpaAIServerNew/ ```
💡 Comentarios sobre la preparación del directorio **sudo mkdir -p** - crea un directorio con carpetas padres * `-p` previene el error si el directorio ya existe **sudo mv** - mueve archivos al nuevo directorio * Mover a `/opt/SherpaAIServerNew` aislará los archivos de migración de la instalación actual
**Lo que se descarga:** * `pgloader_image.tar` - imagen de Docker con pgloader y herramientas necesarias * `alpine_image.tar` - imagen ligera de Alpine Linux para trabajar con volúmenes (no afecta su sistema operativo actual) #### Detención de servicios 1. **Detener contenedores excepto las bases de datos:** ```bash # ir al antiguo directorio cd /opt/SherpaAIServer/ docker compose stop orchestrator embed nginx vllm docker-compose stop orchestrator embed nginx vllm # ir al nuevo directorio cd /opt/SherpaAIServerNew/ ```
💡 Comentarios sobre la detención de servicios **docker compose stop** - detiene los servicios especificados sin eliminarlos * `orchestrator` - servicio principal de orquestación * `embed` - servicio para trabajar con embeddings * `nginx` - servidor web y proxy * `vllm` - servicio de modelo de lenguaje **Dos comandos** - se ejecutaron ambas versiones de la sintaxis para compatibilidad **Servicios restantes** - `pgembeding` (PostgreSQL con embeddings) y `orchestrator-db` (MySQL) deben seguir funcionando para acceder a los datos
{% hint style="info" %} **¿Por qué detenemos los servicios?** Durante la migración es necesario excluir cualquier cambio en la base de datos para garantizar la consistencia de los datos. {% endhint %} {% hint style="info" %} **Nota:** No es necesario eliminar contenedores, solo detenerlos. Deben permanecer `pgembeding` y `orchestrator-db`. {% endhint %} #### Creación de copias de seguridad **Definición de nombres de volúmenes:** Primero, encuentre los nombres correctos de los volúmenes en su sistema: ```bash docker volume list ```
💡 Comentarios sobre la definición de volúmenes **docker volume list** - muestra todos los volúmenes de Docker en el sistema * `DRIVER` - tipo de controlador (generalmente local) * `VOLUME NAME` - nombre único del volumen **El prefijo de los nombres** - depende del nombre de la carpeta del proyecto: * Para la carpeta `SherpaAIServer` → prefijo `sherpaaiserver_` * Para la carpeta `myproject` → prefijo `myproject_` **Volúmenes principales:** * `*orchestrator-mysql-data` - datos de la base de datos MySQL * `*pgdata` - datos de la base de datos PostgreSQL * `*storage` - almacenamiento de archivos
Ejemplo de salida: ``` DRIVER VOLUME NAME local sherpaaiserver_orchestrator-mysql-data local sherpaaiserver_pgdata local sherpaaiserver_storage ``` **Creación de copias de seguridad de volúmenes:** Reemplace los nombres de los volúmenes por los actuales de su lista: ```bash # Copia de seguridad de los datos de MySQL (reemplace VOLUME_NAME por el nombre real) docker run --rm -v VOLUME_NAME:/data -v $(pwd)/backup_mysql:/backup pgembeding tar czf /backup/mysql_backup.tar.gz -C /data . # Copia de seguridad de los datos de PostgreSQL (si existen) (reemplace VOLUME_NAME por el nombre real con postgres) docker run --rm -v VOLUME_NAME:/data -v $(pwd)/backup_pg:/backup pgembeding tar czf /backup/pg_backup.tar.gz -C /data . ```
💡 Comentarios sobre la creación de copias de seguridad **docker run --rm** - ejecuta un contenedor y lo elimina automáticamente después de la ejecución * `--rm` previene la acumulación de contenedores detenidos **Montaje de volúmenes:** * `-v VOLUME_NAME:/data` - monta el volumen de Docker en el contenedor * `-v $(pwd)/backup_mysql:/backup` - monta una carpeta local para guardar el archivo **tar czf** - crea un archivo comprimido * `c` - crear archivo * `z` - comprimir usando gzip * `f` - especificar el nombre del archivo * `-C /data .` - cambia el directorio a /data antes de archivar **pgembeding** - utiliza la imagen existente de PostgreSQL con herramientas
**Ejemplos con nombres específicos:** Para un proyecto en la carpeta `SherpaAIServer`: ```bash docker run --rm -v sherpaaiserver_orchestrator-mysql-data:/data -v $(pwd)/backup_mysql:/backup pgembeding tar czf /backup/mysql_backup.tar.gz -C /data . docker run --rm -v sherpaaiserver_pgdata:/data -v $(pwd)/backup_pg:/backup pgembeding tar czf /backup/pg_backup.tar.gz -C /data . ```
💡 Ejemplo para Sherpa AI Server **Primer volumen:** `sherpaaiserver_orchestrator-mysql-data` * Contiene datos de la base de datos MySQL del orquestador * El archivo se guarda en `backup_mysql/mysql_backup.tar.gz`**Segundo volumen:** `sherpaaiserver_pgdata` * Contiene datos de la base de datos PostgreSQL (si los hay) * El archivo de respaldo se guarda en `backup_pg/pg_backup.tar.gz`
Para el proyecto en la carpeta `myproject`: ```bash docker run --rm -v myproject_orchestrator-mysql-data:/data -v $(pwd)/backup_mysql:/backup pgembeding tar czf /backup/mysql_backup.tar.gz -C /data . docker run --rm -v myproject_pgdata:/data -v $(pwd)/backup_pg:/backup pgembeding tar czf /backup/pg_backup.tar.gz -C /data . ```
💡 Ejemplo para myproject **Primer volumen:** `myproject_orchestrator-mysql-data` * De manera similar, pero con el prefijo `myproject_` * Utilice el nombre real de la carpeta de su proyecto **Segundo volumen:** `myproject_pgdata` * Datos de PostgreSQL con el prefijo correspondiente
💡 Qué hacen estos comandos * Crean archivos comprimidos de todos los datos del volumen de Docker * Los archivos se guardan en los directorios locales `backup_mysql` y `backup_pg`
**Verificación de los respaldos creados:** ```bash # Verifique el tamaño de los archivos ls -lh backup_mysql/ backup_pg/ # Verifique el contenido de los archivos tar -tzf backup_mysql/mysql_backup.tar.gz | head -20 ```
💡 Comentarios sobre la verificación de respaldos **ls -lh** - muestra información detallada sobre los archivos * `-l` - formato largo * `-h` - tamaños en un formato legible * Verifique que los archivos tengan un tamaño razonable **tar -tzf** - muestra el contenido del archivo sin descomprimir * `-t` - lista el contenido * `-z` - descomprimir usando gzip * `-f` - especificar el nombre del archivo * `| head -20` - muestra los primeros 20 archivos **Recomendación:** Asegúrese de que los archivos no estén vacíos y contengan los archivos de base de datos esperados
### Lógica principal de migración #### Descompresión y preparación de herramientas 1. **Descomprimir archivos del cliente:** ```bash tar -xvzf "$(ls client_files_*.tgz | sort -V | tail -n 1)" ```
💡 Comentarios sobre la descompresión **tar -xvzf** - descomprime el archivo * `-x` - extraer * `-v` - salida detallada * `-z` - descomprimir usando gzip * `-f` - especificar el nombre del archivo **Subcomando para seleccionar el archivo:** * `ls client_files_*.tgz` - encuentra todos los archivos comprimidos de client-files * `sort -V` - ordena por versión (1.0, 1.1, 2.0, etc.) * `tail -n 1` - toma el último (el más reciente) archivo **Resultado:** Se crea una carpeta `pgloader` con herramientas de migración
2. **Ir al directorio pgloader:** ```bash cd pgloader ```
💡 Comentarios sobre el cambio de directorio **cd pgloader** - cambia a la carpeta con herramientas de migración * Todos los comandos posteriores se ejecutan desde este directorio * Contiene scripts y configuraciones para pgloader
3. **Cargar la imagen de Docker pgloader:** ```bash ./load_pgloader.sh ```
💡 Comentarios sobre la carga de la imagen **./load\_pgloader.sh** - script para cargar la imagen de Docker * Importa `pgloader_image.tar` en el daemon de Docker local * Después de la ejecución, la imagen estará disponible como `pgloader:latest` * Puede tardar unos minutos dependiendo del tamaño de la imagen
4. **Construir el contenedor para la migración:** ```bash ./run.sh build ```
💡 Comentarios sobre la construcción del contenedor **./run.sh build** - construye el contenedor de Docker para la migración * Crea un contenedor basado en la imagen de pgloader cargada * Configura todas las dependencias y herramientas necesarias * Después de la construcción, el contenedor está listo para ejecutar la migración
#### Configuración de la configuración de migración **Creación del archivo `.env` con parámetros de conexión:** Todas las contraseñas se pueden encontrar en el archivo `oais/backend/config/config.ini`. ```bash cp .env.template .env nano .env # URI para la base de datos MySQL de origen MIGRATE_MYSQL="mysql://user:pass@host:port/db" # URI para la base de datos PostgreSQL de destino MIGRATE_PG="postgres://user:pass@host:port/db" # Parámetros para crear un volcado (opcional) DUMP_PATH="/path/para/volcado" DUMP_URI="mysql://user:pass@host/db" # Parámetros para la restauración (opcional) RESTORE_URI="postgres://user:pass@host/db" RESTORE_PATH="/path/al/volcado.sql" ```
💡 Comentarios sobre las variables de entorno **MIGRATE\_MYSQL** - URI de conexión a la base de datos MySQL de origen * Formato: `mysql://username:password@host:port/database` * Utilizado por pgloader para leer datos **MIGRATE\_PG** - URI de conexión a la base de datos PostgreSQL de destino * Formato: `postgres://username:password@host:port/database` * Debe estar disponible para escribir datos *DUMP\_ / RESTORE\_* \*\* - parámetros opcionales para crear/restaurar volcados * Útiles para depuración o migración por etapas
**Ejemplo de configuración funcional:** ```env # Para la base de datos MySQL DUMP_URI="mysql://root:pass@91.206.149.183:3306/orchestrator" MIGRATE_MYSQL="mysql://root:pass@91.206.149.183:3306/orchestrator" # Para la base de datos PostgreSQL MIGRATE_PG="postgres://postgres:pass@91.206.149.183:5432/postgres" ```
💡 Ejemplo de configuración **Parámetros de MySQL:** * Host: `91.206.149.183` (servidor externo) * Puerto: `3306` (estándar para MySQL) * Base: `orchestrator` * Usuario: `root` (con todos los permisos) **Parámetros de PostgreSQL:** * Host: el mismo servidor * Puerto: `5432` (estándar para PostgreSQL) * Base: `postgres` (base de datos del sistema) * Usuario: `postgres` (administrador) **Importante:** Las contraseñas deben tomarse del `config.ini` existente
> **Importante:** Asegúrese de que los puertos y hosts sean accesibles desde el contenedor de Docker. #### Ejecución de la migración **Ejecución de prueba (recomendada)** ```bash ./run.sh dry-run ```
💡 Comentarios sobre la ejecución de prueba **./run.sh dry-run** - simulación de la migración sin cambios * Se conecta a ambas bases de datos * Analiza la estructura y los datos * Muestra el plan de migración y posibles problemas * No realiza ningún cambio en PostgreSQL **Verifica:** * Disponibilidad y corrección de las conexiones * Compatibilidad de tipos de datos MySQL → PostgreSQL * Existencia de todas las tablas y relaciones * Volumen de datos esperado para la transferencia **Recomendación:** Siempre realice una ejecución de prueba antes de la migración real
**Migración principal** ```bash ./run.sh migrate ```
💡 Comentarios sobre la migración principal **./run.sh migrate** - realiza la migración real de datos * Crea el esquema `orchestrator` en PostgreSQL * Transfiere la estructura de las tablas con conversión de tipos * Copia todos los datos de MySQL a PostgreSQL * Crea índices y restricciones de integridad **Etapas de ejecución:** 1. Verificación de conexiones y permisos 2. Creación del esquema de la base de datos 3. Migración de la estructura (tablas, tipos de datos) 4. Transferencia de datos con optimización del rendimiento 5. Creación de índices y restricciones **Importante:** El proceso puede ser largo para bases de datos grandes
**Opciones de migración:** * `--force` - realizar la migración incluso si el esquema ya existe * `--build` - reconstruir el contenedor antes de ejecutar * `--rmi` - eliminar la imagen después de completar {% hint style="info" %} **Tiempo de ejecución:** Depende del tamaño de la base de datos. Para bases de datos de hasta 10 GB - de 30 minutos a varias horas. Para bases de datos grandes - puede tardar varias horas o días. {% endhint %} #### Limpieza después de la migración ```bash # Eliminación de la imagen de Docker pgloader (opcional) ./run.sh rmi # Regreso al directorio raíz del proyecto cd .. ```
💡 Comentarios sobre la limpieza **./run.sh rmi** - elimina la imagen de Docker pgloader * Libera espacio en disco * Elimina imágenes y contenedores temporales * Opcional - se puede dejar para reutilización **cd ..** - regresa al directorio padre * Sale de la carpeta pgloader * Regresa a la raíz del proyecto SherpaAIServer **Recomendación:** Realice la limpieza solo después de una finalización y prueba exitosa de la migración
### Copia de datos en nuevos volúmenes Después de una migración exitosa de la base de datos, puede ser necesario transferir el almacenamiento de archivos entre volúmenes de Docker. #### Carga de la imagen de Alpine ```bash docker load -i alpine_image.tar ```
💡 Comentarios sobre la carga de Alpine **docker load -i** - importa una imagen de Docker desde un archivo tar * `-i` - leer desde un archivo tar guardado localmente * Carga la imagen en el daemon de Docker local **Alpine Linux** - distribución de Linux minimalista * Tamaño de la imagen \~5-10 MB (en comparación con Ubuntu \~100+ MB) * Contiene solo las herramientas necesarias (cp, ls, tar, etc.) * Ideal para operaciones con archivos en contenedores **Uso:** Para copiar datos entre volúmenes de Docker
#### Creación de un nuevo volumen ```bash docker volume create aiserver-storage ```
💡 Comentarios sobre la creación de un volumen **docker volume create** - crea un nuevo volumen de Docker nombrado * `aiserver-storage` - nombre para el nuevo volumen * El volumen se crea vacío y listo para usar **Características del volumen:** * Gestionado automáticamente por Docker * Accesible para todos los contenedores en el host * Se conserva al reiniciar el daemon de Docker * Soporta operaciones de snapshot y backup **Propósito:** Almacenamiento de archivos de Sherpa AIServer (descargas, caché, logs, etc.)
#### Definición de volúmenes actuales **Encontrar nombres de volúmenes utilizados:** ```bash docker volume list ```
💡 Redefinición de volúmenes **docker volume list** - verificación reiterada de la lista de volúmenes * Asegurarse de que todos los volúmenes estén disponibles * Verificar la corrección de los nombres antes de copiar datos **Importante:** Comparar con los resultados de la primera verificación * Asegúrese de que los volúmenes no hayan sido eliminados accidentalmente * Verifique la disponibilidad de todos los datos necesarios
Ejemplo de salida (los nombres dependen del nombre de la carpeta del proyecto): ``` DRIVER VOLUME NAME local sherpaaiserver_orchestrator-mysql-data local sherpaaiserver_pgdata local sherpaaiserver_storage ``` O, si la carpeta del proyecto se llama de otra manera (por ejemplo, `myproject`): ``` DRIVER VOLUME NAME local myproject_orchestrator-mysql-data local myproject_pgdata local myproject_storage ``` #### Transferencia de datos entre volúmenes **Definir la fuente de datos:** En el siguiente comando, reemplace `STORAGE_DATA` con el nombre de su volumen actual para almacenar datos (por ejemplo, `sherpaaiserver_storage`): ```bash docker run --rm \ -v STORAGE_DATA:/from \ -v aiserver-storage:/to \ alpine ash -c "cp -av /from/. /to/" ```
💡 Comentarios sobre la transferencia de datos **docker run --rm** - inicia un contenedor temporal de Alpine * `--rm` - el contenedor se eliminará después de la ejecución **Montaje de volúmenes:** * `-v STORAGE_DATA:/from` - el volumen fuente se monta en /from * `-v aiserver-storage:/to` - el volumen de destino se monta en /to **ash -c** - ejecuta un comando en el shell de Alpine * `ash` - Almquist shell (ligero) * `-c` - ejecutar el comando **cp -av /from/. /to/** - copia todos los archivos * `-a` - modo de archivo (mantiene permisos, propietarios, marcas de tiempo) * `-v` - salida detallada * `/from/.` - copia el contenido, no la carpeta /from * `/to/` - en el directorio de destino **Ejemplo de reemplazo:** `STORAGE_DATA` → `sherpaaiserver_storage`
**Verificación del éxito de la copia:** ```bash # Verificar el contenido del nuevo volumen docker run --rm -v aiserver-storage:/data alpine ls -la /data # Comparar tamaños (aproximados) docker run --rm -v STORAGE_DATA:/data alpine du -sh /data docker run --rm -v aiserver-storage:/data alpine du -sh /data ```
💡 Comentarios sobre la verificación de la copia **docker run --rm -v aiserver-storage:/data alpine ls -la /data** * Verifica el contenido del nuevo volumen * `ls -la` muestra todos los archivos con permisos y tamaños * Asegurarse de que los archivos se hayan copiado correctamente **docker run --rm -v STORAGE\_DATA:/data alpine du -sh /data** * Verifica el tamaño del volumen fuente * `du -sh` - uso de disco, resumen, formato legible por humanos * Comparamos tamaños para verificar la integridad de la copia **Expectativas:** * La cantidad de archivos debe coincidir * Los tamaños deben ser aproximadamente iguales * La estructura de directorios debe ser idéntica **Si los tamaños difieren:** Verifique los registros de copia en busca de errores
### Migración de PostgreSQL 16 a la versión 17 #### Preparación para la actualización de la versión de PostgreSQL **Acciones preliminares:** 1. **Dejar la base de datos antigua en ejecución** - el contenedor `pgembeding` debe seguir funcionando 2. **Descomprimir los nuevos archivos de cliente** - el archivo debe contener el `docker-compose.yml` y el `.env` actualizados 3. **Transferir la configuración** - copiar los parámetros de conexión de la versión antigua `/opt/SherpaAIServer/oais/backend/config/config.ini` al nuevo `.env` 4. **Cambiar el puerto** - establecer temporalmente el puerto 5433 para el nuevo PostgreSQL, para evitar conflictos #### Descompresión del archivo con los archivos de cliente ```bash # Encuentre y descomprima el archivo (se selecciona automáticamente la versión más reciente) tar -xvzf "$(ls client_files_*.tgz | sort -V | tail -n 1)" ```
💡 Qué hace este comando * `ls client_files_*.tgz` - encuentra todos los archivos de archivo * `sort -V` - ordena versiones de forma natural (1.0 < 1.1 < 1.10) * `tail -n 1` - selecciona el archivo más reciente * `tar -xvzf` - descomprime el archivo mostrando el contenido **Resultado esperado:** Se creará un directorio `sh_scripts/` con scripts ejecutables y otros archivos necesarios.
#### Preparación de scripts para ejecución ```bash # Cambie al directorio con los scripts cd sh_scripts/ # Haga que todos los scripts sean ejecutables chmod +x *.sh # Regrese al directorio raíz del proyecto cd .. ```
💡 Qué hacen estos comandos * `chmod +x *.sh` - establece permisos de ejecución para todos los scripts de shell * Esto es necesario para ejecutar los scripts en las siguientes etapas de la instalación
#### Estructura del archivo descomprimido: Después de descomprimir, debe ver los siguientes archivos y directorios: * `sh_scripts/` - directorio con scripts de instalación * `download_all_latest_docker_images.sh` - script para descargar imágenes de Docker * `load_all_docker_images.sh` - script para cargar imágenes en Docker * `extract_models.sh` - script para descomprimir modelos de IA * `extract_llama.sh` - script para descomprimir modelos LLM * `docker-compose.yml` - configuración de Docker Compose para la instalación del cliente * `.env` - archivo con variables de entorno para configurar el sistema #### Carga de imágenes de Docker ```bash # Ejecute el script de carga de imágenes de Docker sudo ./sh_scripts/load_all_docker_images.sh ```
💡 Qué hace el script 1. Carga todas las imágenes de Docker desde los archivos .tar.gz descargados 2. Importa las imágenes en el registro local de Docker 3. Verifica el éxito de la carga
#### Descompresión de modelos de IA ```bash # Ejecute el script de descompresión de modelos principales sudo ./sh_scripts/extract_models.sh ```
💡 Qué hace el script 1. Descomprime el modelo Whisper para reconocimiento de voz 2. Descomprime el modelo BGE Reranker para mejorar la búsqueda 3. Descomprime modelos para generación de embeddings 4. Crea los directorios necesarios 5. Verifica el éxito de la descompresión
```bash # Ejecute el script de descompresión del modelo LLM sudo ./sh_scripts/extract_llama.sh ```
💡 Qué hace el script 1. Descomprime el modelo Llama 3 para modelado de lenguaje 2. Elimina el prefijo `model-store/` de las rutas de los archivos 3. Coloca los archivos directamente en el directorio de modelos 4. Verifica el contenido después de la descompresión
#### Estructura de directorios después de la descompresión (aproximada):\`\`\` ./whisper/ └── models/ ├── base.pt └── ... ./bge\_reranker/ └── models/ └── bge-reranker-large/ ├── config.json ├── model.bin └── ... ./embed-server/app/ └── model-store/ └── sentence-transformers/ └── paraphrase-multilingual-MiniLM-L12-v2/ ├── config.json ├── pytorch\_model.bin └── ... ./llm-server/models/ ├── meta-llama/ │ └── Meta-Llama-3-8B-Instruct/ │ ├── config.json │ ├── model-00001-of-00004.safetensors │ ├── model-00002-of-00004.safetensors │ └── ... └── tokenizer.json ```` #### Ejecución de una nueva versión de PostgreSQL ```bash docker compose up -d ````
💡 Comentarios sobre la ejecución de una nueva versión **docker compose up -d** - inicia los servicios en segundo plano * `-d` - modo desconectado (ejecución en segundo plano) * Inicia todos los servicios del docker-compose.yml * Incluye PostgreSQL 17 en el contenedor aiserver-pg **Importante:** * La base de datos antigua debe seguir funcionando * La nueva versión se inicia en otro puerto (5433) * El proceso de inicialización puede tardar varios minutos
**Monitoreo de la ejecución:** ```bash # Seguir los logs de inicialización docker logs aiserver # Verificar el estado de los contenedores docker ps | grep aiserver ```
💡 Comentarios sobre el monitoreo **docker logs aiserver** - muestra los logs del contenedor * Sigue el proceso de inicialización de PostgreSQL * Busca mensajes sobre el inicio exitoso y la aplicación de migraciones * Se puede interrumpir con Ctrl+C **docker ps | grep aiserver** - verifica el estado * `docker ps` - muestra los contenedores en ejecución * `grep aiserver` - filtra por nombre * Debe mostrar el contenedor aiserver-pg en estado Up
#### Detener servicios para la transferencia de datos **Detener todos los servicios excepto la nueva base de datos:** ```bash docker-compose stop aiserver aiserver-code_interpreter aiserver-llm-server aiserver-embed aiserver-whisper aiserver-bge_reranker docker compose stop aiserver aiserver-code_interpreter aiserver-llm-server aiserver-embed aiserver-whisper aiserver-bge_reranker ```
💡 Comentarios sobre la detención de servicios **docker compose stop** - detiene los servicios especificados * Se ejecutan ambas versiones de la sintaxis por compatibilidad * Se detienen todos los servicios de Sherpa AIServer excepto la base de datos **Servicios detenidos:** * `aiserver` - servidor web principal * `aiserver-code_interpreter` - intérprete de código * `aiserver-llm-server` - modelo de lenguaje * `aiserver-embed` - servicio de embeddings * `aiserver-whisper` - servicio de reconocimiento de voz * `aiserver-bge_reranker` - servicio de ranking **Resultado:** Solo `aiserver-pg` (nueva PostgreSQL) sigue funcionando
#### Transferencia de datos entre versiones **Ejecutar la secuencia de comandos para la transferencia de datos:** ```bash # 1. Crear un volcado de la base de datos antigua docker exec -t postgres pg_dump -U postgres -d postgres -Fc -f /tmp/postgres.dump && \ # 2. Copiar el volcado al host docker cp postgres:/tmp/postgres.dump ./postgres.dump && \ # 3. Eliminar la base de datos antigua en el nuevo contenedor docker exec -it aiserver-pg psql -U postgres -d template1 -c "DROP DATABASE IF EXISTS postgres;" && \ # 4. Crear una nueva base de datos docker exec -it aiserver-pg psql -U postgres -d template1 -c "CREATE DATABASE postgres;" && \ # 5. Crear las extensiones necesarias docker exec -it aiserver-pg psql -U postgres -d postgres -c "CREATE EXTENSION IF NOT EXISTS embedding;" && \ docker exec -it aiserver-pg psql -U postgres -d postgres -c "CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";" && \ # 6. Copiar el volcado al nuevo contenedor docker cp ./postgres.dump aiserver-pg:/tmp/postgres.dump && \ # 7. Restaurar los datos docker exec -t aiserver-pg pg_restore -U postgres -d postgres /tmp/postgres.dump ```
💡 Comentarios sobre la transferencia entre versiones de PostgreSQL **Paso 1: Crear un volcado de la base de datos antigua** * `docker exec -t postgres` - ejecuta el comando en el contenedor postgres (versión 16) * `pg_dump -U postgres -d postgres -Fc` - crea un volcado en formato especial * `-Fc` - formato especial comprimido (mejor para bases de datos grandes) * Se guarda en `/tmp/postgres.dump` dentro del contenedor **Paso 2: Copiar el volcado al host** * `docker cp postgres:/tmp/postgres.dump ./postgres.dump` * Transfiere el volcado del contenedor al disco local * Necesario para la transferencia entre contenedores **Paso 3: Eliminar la base de datos antigua en el nuevo contenedor** * Se conecta a la base de datos del sistema template1 * Elimina la base de datos existente postgres (si existe) **Paso 4: Crear una nueva base de datos** * Crea una base de datos postgres limpia en el contenedor aiserver-pg **Paso 5: Crear extensiones** * `embedding` - extensión para embeddings vectoriales * `uuid-ossp` - generación de UUID (necesaria para algunas tablas) **Paso 6: Copiar el volcado al nuevo contenedor** * Operación inversa de copia * Coloca el volcado en el contenedor aiserver-pg **Paso 7: Restaurar los datos** * `pg_restore` - restaura desde el volcado en formato especial * `-t` - asigna TTY para el progreso * Crea automáticamente tablas, índices y datos
### Validación de los resultados de la migración #### Verificación de la correcta transferencia de datos **Verificaciones básicas:** ```bash # Conectarse a la nueva base de datos docker exec -it aiserver-pg psql -U postgres -d postgres # Verificar el número de tablas \dt orchestrator.* # Verificar el número de registros en las tablas principales SELECT schemaname, tablename, n_tup_ins AS rows FROM pg_stat_user_tables WHERE schemaname = 'orchestrator' ORDER BY n_tup_ins DESC; # Verificar la existencia de extensiones \dx # Salir de psql \q ```
💡 Comentarios sobre las verificaciones básicas **docker exec -it aiserver-pg psql -U postgres -d postgres** * Se conecta a PostgreSQL en modo interactivo * `-it` - terminal interactivo * `-U postgres` - usuario postgres * `-d postgres` - base de datos postgres **\dt orchestrator.**\* - muestra todas las tablas en el esquema orchestrator * `\dt` - lista de tablas * `orchestrator.*` - filtro por esquema **SELECT ... FROM pg\_stat\_user\_tables** - estadísticas sobre las tablas * `n_tup_ins` - número de filas insertadas (número aproximado de registros) * La ordenación descendente muestra las tablas más grandes **\dx** - muestra las extensiones instaladas * Deben ser visibles `embedding` y `uuid-ossp` **\q** - salir de psql
#### Pruebas de funcionalidad 1. **Iniciar los servicios principales de Sherpa AI Server** 2. **Realizar consultas de prueba a la API** 3. **Verificar el funcionamiento de la interfaz web** 4. **Realizar operaciones básicas con los datos** ### Diagnóstico y resolución de problemas #### Errores comunes y soluciones **Si se producen errores de migración, comuníquese con el soporte técnico, mientras tanto, puede regresar al antiguo directorio /opt/SherpaAIServer y ejecutar con la configuración anterior Sherpa AI Server** **"Heap exhausted" o falta de memoria** ``` Solución: Aumentar el límite de memoria para pgloader export SBCL_DYNAMIC_SPACE_SIZE=8192 ``` **Error de conexión a la base de datos** ``` Verificaciones: - Verificar la disponibilidad de puertos: telnet host port - Verificar la validez de las credenciales - Verificar la conectividad de red de los contenedores ``` **Violación de la integridad de los datos** ``` Acciones: 1. Verificar los logs de pgloader: cat migrate.log 2. Comparar el número de registros en la base de datos fuente y destino 3. Verificar la existencia de todas las tablas e índices ``` **Interrupción de la migración** ``` Acciones: - No reiniciar la migración - Contactar al soporte técnico con los logs - Proporcionar: migrate.log, configuración .env, tamaño de la base de datos ```
💡 Comentarios sobre el monitoreo de la migración **tail -f migrate.log** - sigue los logs en tiempo real * `-f` - seguir (se actualiza al agregar nuevas líneas) * Muestra el progreso de la migración de pgloader * Busca errores o advertencias **docker stats** - monitorea el uso de recursos de los contenedores * Muestra CPU, memoria, red, disco para todos los contenedores * Útil para rastrear la carga en el sistema * Interrumpir con Ctrl+C ```**watch * Cuenta el número total de registros en todas las tablas del orchestrator * `watch` - utilidad para ejecutar comandos periódicamente * `-n 30` - intervalo de 30 segundos **Uso:** Mantener estos comandos en terminales separados durante la migración
### Finalización de la migración **Después de completar con éxito todos los pasos:** 1. **Iniciar todos los servicios de Sherpa AI Server** 2. **Realizar pruebas finales del sistema** 3. **Eliminar archivos temporales y contenedores antiguos** (si es necesario) > **Recomendación:** Guarde los registros de migración y los archivos de configuración para futuras referencias. ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.sherparpa.ru/es/obnovleniya/obnovleniya-sherpa-ai-server/versiya-2.2.0/instrukciya-po-migracii-mysql-postgresql.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.