Astro DB

Astro DB es una base de datos SQL completamente gestionada diseñada para el ecosistema de Astro. Desarrolla localmente en Astro y despliega en cualquier base de datos compatible con libSQL.

Astro DB es una solución completa para configurar, desarrollar y consultar tus datos. Una base de datos local se crea en .astro/content.db cada vez que ejecutas astro dev para gestionar tus datos sin necesidad de Docker o una conexión de red.

Instalación

Instala la integración @astrojs/db (EN) usando el comando incorporado astro add:

npx astro add db

pnpm astro add db

yarn astro add db

Define tu base de datos

Instalar @astrojs/db con el comando astro add creará automáticamente un archivo db/config.ts en tu proyecto donde definirás las tablas de tu base de datos:

import { defineDb } from 'astro:db';

export default defineDb({
  tables: { },
})

Tablas

Los datos en Astro DB se almacenan usando tablas SQL. Las tablas estructuran tus datos en filas y columnas, donde las columnas hacen cumplir el tipo de cada valor de fila.

Define tus tablas en tu archivo db/config.ts proporcionando la estructura de los datos en tu base de datos libSQL existente, o los datos que recopilarás en una nueva base de datos. Esto permitirá a Astro generar una interfaz de TypeScript para consultar esa tabla desde tu proyecto. El resultado es soporte completo de TypeScript cuando accedes a tus datos con autocompletado de propiedades y verificación de tipos.

Para configurar una tabla de base de datos, importa y usa las utilidades defineTable() y column desde astro:db. Luego, define un nombre (sensible a mayúsculas) para tu tabla y el tipo de datos en cada columna.

Este ejemplo configura una tabla Comment con columnas de texto obligatorias para author y body. Luego, la hace disponible para tu proyecto a través de la exportación defineDb().

import { defineDb, defineTable, column } from 'astro:db';

const Comment = defineTable({
  columns: {
    author: column.text(),
    body: column.text(),
  }
})

export default defineDb({
  tables: { Comment },
})

Consulta la referencia de configuración de tablas (EN) para una referencia completa de las opciones de tabla.

Columnas

Astro DB admite los siguientes tipos de columna:

import { defineTable, column } from 'astro:db';

const Comment = defineTable({
  columns: {
    // Una cadena de texto.
    author: column.text(),
    // Un valor entero completo.
    likes: column.number(),
    // Un valor verdadero o falso.
    flagged: column.boolean(),
    // Valores de fecha/hora consultados como objetos Date de JavaScript.
    published: column.date(),
    // Un objeto JSON sin tipo.
    metadata: column.json(),
  }
});

Consulta la referencia de columnas de tabla (EN) para más detalles.

Referencias de Tabla

Las relaciones entre tablas son un patrón común en el diseño de bases de datos. Por ejemplo, una tabla Blog puede estar estrechamente relacionada con otras tablas de Comment, Author y Category.

Puedes definir estas relaciones entre tablas y guardarlas en tu esquema de base de datos usando columnas de referencia. Para establecer una relación, necesitarás:

Una columna identificadora en la tabla referenciada. Suele ser una columna id con la propiedad primaryKey.
Una columna en la tabla base para almacenar el id referenciado. Esto usa la propiedad references para establecer una relación.

Este ejemplo muestra una columna authorId de la tabla Comment que referencia una columna id de la tabla Author.

const Author = defineTable({
  columns: {
    id: column.number({ primaryKey: true }),
    name: column.text(),
  }
});

const Comment = defineTable({
  columns: {
    authorId: column.number({ references: () => Author.columns.id }),
    body: column.text(),
  }
});

Sembrar tu base de datos para desarrollo

En desarrollo, Astro usará tu configuración de DB para generar tipos locales según tus esquemas. Estos se generarán de nuevo desde tu archivo de semilla cada vez que se inicie el servidor de desarrollo, y te permitirán consultar y trabajar con la forma de tus datos con seguridad de tipos y autocompletado.

No tendrás acceso a datos de producción durante el desarrollo a menos que te conectes a una base de datos remota durante el desarrollo. Esto protege tus datos mientras te permite probar y desarrollar con una base de datos funcional con seguridad de tipos.

Para sembrar datos de desarrollo para pruebas y depuración en tu proyecto de Astro, crea un archivo db/seed.ts. Importa tanto el objeto db como tus tablas definidas en astro:db. inserta algunos datos iniciales en cada tabla. Estos datos de desarrollo deben coincidir con la forma de tu esquema de base de datos y de los datos de producción.

El siguiente ejemplo define dos filas de datos de desarrollo para una tabla Comment y una tabla Author:

import { db, Comment, Author } from 'astro:db';

export default async function() {
  await db.insert(Author).values([
    { id: 1, name: "Kasim" },
    { id: 2, name: "Mina" },
  ]);

  await db.insert(Comment).values([
    { authorId: 1, body: '¡Espero que te guste Astro DB!' },
    { authorId: 2, body: '¡Disfrútalo!'},
  ])
}

Tu servidor de desarrollo reiniciará automáticamente tu base de datos cada vez que este archivo cambie, regenerando tus tipos y sembrando estos datos de desarrollo desde seed.ts de nuevo cada vez.

Conecta una base de datos libSQL para producción

Astro DB puede conectarse a cualquier base de datos libSQL local o a cualquier servidor que exponga el protocolo remoto de libSQL, ya sea gestionado o autoalojado.

Para conectar Astro DB a una base de datos libSQL, establece las siguientes variables de entorno obtenidas de tu proveedor de base de datos:

ASTRO_DB_REMOTE_URL: la URL de conexión a la ubicación de tu base de datos libSQL local o remota. Esto puede incluir opciones de configuración de URL como sincronización y cifrado como parámetros.
ASTRO_DB_APP_TOKEN: el token de autenticación para tu servidor libSQL. Esto es obligatorio para bases de datos remotas, y no es necesario para bases de datos locales como archivos o en memoria

Dependiendo de tu servicio, puedes tener acceso a una CLI o interfaz web para recuperar estos valores. La siguiente sección demostrará conectarse a Turso y establecer estos valores como ejemplo, pero eres libre de usar cualquier proveedor.

Comenzando con Turso

Turso es la empresa detrás de libSQL, el fork de código abierto de SQLite que impulsa Astro DB. Proporcionan una plataforma de base de datos libSQL completamente gestionada y son totalmente compatibles con Astro.

Los pasos a continuación te guiarán a través del proceso de instalar la CLI de Turso, iniciar sesión (o registrarte), crear una nueva base de datos, obtener las variables de entorno requeridas y empujar el esquema a la base de datos remota.

Instala la CLI de Turso.
Inicia sesión o regístrate en Turso.
Crea una nueva base de datos. En este ejemplo el nombre de la base de datos es andromeda.
Ventana de terminal
```
turso db create andromeda
```
Ejecuta el comando show para ver información sobre la base de datos recién creada:
Ventana de terminal
```
turso db show andromeda
```
Copia el valor URL y establécelo como el valor para ASTRO_DB_REMOTE_URL.
.env
```
ASTRO_DB_REMOTE_URL=libsql://andromeda-houston.turso.io
```
Crea un nuevo token para autenticar las solicitudes a la base de datos:
Ventana de terminal
```
turso db tokens create andromeda
```
Copia la salida del comando y establécelo como el valor para ASTRO_DB_APP_TOKEN.
.env
```
ASTRO_DB_REMOTE_URL=libsql://andromeda-houston.turso.io
ASTRO_DB_APP_TOKEN=eyJhbGciOiJF...3ahJpTkKDw
```
Empuja tu esquema de DB y metadatos a la nueva base de datos de Turso.
Ventana de terminal
```
astro db push --remote
```
¡Felicidades, ahora tienes una base de datos conectada! Date un descanso. 👾
Ventana de terminal
```
turso relax
```

Para explorar más características de Turso, consulta la documentación de Turso.

Conectando a bases de datos remotas

Astro DB te permite conectarte tanto a bases de datos locales como remotas. Por defecto, Astro usa un archivo de base de datos local para los comandos dev y build, recreando tablas e insertando datos de semilla de desarrollo cada vez.

Para conectarte a una base de datos remota alojada, usa la bandera --remote. Esta bandera habilita tanto acceso de lectura como escritura a tu base de datos remota, permitiéndote aceptar y persistir datos de usuarios en entornos de producción.

Configura tu comando de construcción para usar la bandera --remote:

{
  "scripts": {
    "build": "astro build --remote"
  }
}

También puedes usar la bandera directamente en la línea de comandos:

# Construir con una conexión remota
astro build --remote

# Desarrollar con una conexión remota
astro dev --remote

La bandera --remote usa la conexión a la base de datos remota tanto localmente durante la construcción como en el servidor. Asegúrate de establecer las variables de entorno necesarias tanto en tu entorno de desarrollo local como en tu plataforma de despliegue. Además, es posible que necesites configurar el modo web (EN) para entornos de ejecución que no sean Node.js, como Cloudflare Workers o Deno.

Al desplegar tu proyecto de Astro DB, asegúrate de que el comando de construcción de tu plataforma de despliegue esté configurado como npm run build (o el equivalente para tu gestor de paquetes) para utilizar la bandera --remote configurada en tu package.json.

Opciones de configuración de URL remota

La variable de entorno ASTRO_DB_REMOTE_URL configura la ubicación de tu base de datos, así como otras opciones como sincronización y cifrado.

Esquema de URL y host

libSQL admite tanto HTTP como WebSockets como protocolo de transporte para un servidor remoto. También admite usar un archivo local o una base de datos en memoria. Estos se pueden configurar usando los siguientes esquemas de URL en la URL de conexión:

memory: usará una base de datos en memoria. El host debe estar vacío en este caso.
file: usará un archivo local. El host es la ruta al archivo (file:path/to/file.db).
libsql: usará un servidor remoto a través del protocolo preferido por la biblioteca (esto puede variar entre versiones). El host es la dirección del servidor (libsql://your.server.io).
http: usará un servidor remoto a través de HTTP. Se puede usar https: para habilitar una conexión segura. El host es el mismo que para libsql:.
ws: usará un servidor remoto a través de WebSockets. Se puede usar wss: para habilitar una conexión segura. El host es el mismo que para libsql:.

Los detalles de la conexión libSQL (por ejemplo, clave de cifrado, replicación, intervalo de sincronización) se pueden configurar como parámetros de consulta en la URL de conexión remota.

Por ejemplo, para tener un archivo local cifrado que funcione como una réplica embebida de un servidor libSQL, puedes establecer las siguientes variables de entorno:

ASTRO_DB_REMOTE_URL=file://local-copy.db?encryptionKey=your-encryption-key&syncInterval=60&syncUrl=libsql%3A%2F%2Fyour.server.io
ASTRO_DB_APP_TOKEN=token-to-your-remote-url

`encryptionKey`

libSQL tiene soporte nativo para bases de datos cifradas. Pasar este parámetro de búsqueda habilitará el cifrado usando la clave dada:

ASTRO_DB_REMOTE_URL=file:path/to/file.db?encryptionKey=your-encryption-key

`syncUrl`

Las réplicas embebidas son una característica de los clientes libSQL que crea una copia completamente sincronizada de tu base de datos en un archivo local o en memoria para lecturas ultrarrápidas. Las escrituras se envían a una base de datos remota definida en syncUrl y se sincronizan con la copia local.

Usa esta propiedad para pasar una URL de conexión separada para convertir la base de datos en una réplica embebida de otra base de datos. Esto solo debe usarse con los esquemas file: y memory:. El parámetro debe estar codificado en URL.

Por ejemplo, para tener una réplica embebida en memoria de una base de datos en libsql://your.server.io, puedes establecer la URL de conexión así:

ASTRO_DB_REMOTE_URL=memory:?syncUrl=libsql%3A%2F%2Fyour.server.io

`syncInterval`

Intervalo entre sincronizaciones de réplicas embebidas en segundos. Por defecto solo se sincroniza al inicio y después de escrituras.

Esta propiedad solo se usa cuando syncUrl también está establecida. Por ejemplo, para establecer una réplica embebida en memoria que se sincronice cada minuto, establece la siguiente variable de entorno:

ASTRO_DB_REMOTE_URL=memory:?syncUrl=libsql%3A%2F%2Fyour.server.io&syncInterval=60

Consulta tu base de datos

Puedes consultar tu base de datos desde cualquier página de Astro, endpoint (EN), o acción en tu proyecto usando el ORM db y el constructor de consultas proporcionados.

Drizzle ORM

import { db } from 'astro:db';

Astro DB incluye un cliente Drizzle ORM incorporado. No se requiere configuración o configuración manual para usar el cliente. El cliente db de Astro DB se configura automáticamente para comunicarse con tu base de datos (local o remota) cuando ejecutas Astro. Usa tu definición exacta de esquema de base de datos para consultas SQL con seguridad de tipos con errores de TypeScript cuando haces referencia a una columna o tabla que no existe.

Seleccionar

El siguiente ejemplo selecciona todas las filas de una tabla Comment. Esto devuelve el arreglo completo de datos de desarrollo sembrados desde db/seed.ts que luego está disponible para usar en tu plantilla de página:

---
import { db, Comment } from 'astro:db';

const comments = await db.select().from(Comment);
---

<h2>Comentarios</h2>

{
  comments.map(({ author, body }) => (
    <article>
      <p>Autor: {author}</p>
      <p>{body}</p>
    </article>
  ))
}

Consulta la referencia de la API select() de Drizzle para una descripción completa.

Insertar

Para aceptar entrada de usuario, como manejar solicitudes de formularios e insertar datos en tu base de datos remota alojada, configura tu proyecto de Astro para renderizado bajo demanda y agrega un adaptador para tu entorno de despliegue.

Este ejemplo inserta una fila en una tabla Comment basada en una solicitud POST de formulario analizada:

---
import { db, Comment } from 'astro:db';

if (Astro.request.method === 'POST') {
  // Analiza los datos del formulario
  const formData = await Astro.request.formData();
  const author = formData.get('author');
  const body = formData.get('body');
  if (typeof author === 'string' && typeof body === 'string') {
    // Inserta los datos del formulario en la tabla Comment
    await db.insert(Comment).values({ author, body });
  }
}

// Renderiza la nueva lista de comentarios en cada solicitud
const comments = await db.select().from(Comment);
---

<form method="POST" style="display: grid">
  <label for="author">Autor</label>
  <input id="author" name="author" />

  <label for="body">Cuerpo</label>
  <textarea id="body" name="body"></textarea>

  <button type="submit">Enviar</button>
</form>

<!-- Renderiza `comments` -->

También puedes usar acciones de Astro para insertar datos en una tabla de Astro DB. El siguiente ejemplo inserta una fila en una tabla Comment usando una acción:

import { db, Comment } from 'astro:db';
import { defineAction } from 'astro:actions';
import { z } from 'astro/zod';

export const server = {
  addComment: defineAction({
    // Las acciones incluyen seguridad de tipos con Zod, eliminando la necesidad
    // de verificar si typeof {valor} === 'string' en tus páginas
    input: z.object({
      author: z.string(),
      body: z.string(),
    }),
    handler: async (input) => {
      const updatedComments = await db
        .insert(Comment)
        .values(input)
        .returning(); // Devuelve los comentarios actualizados
      return updatedComments;
    },
  }),
};

Consulta la referencia de la API insert() de Drizzle para una descripción completa.

Eliminar

También puedes consultar tu base de datos desde un endpoint de API. Este ejemplo elimina una fila de una tabla Comment por el parámetro id:

import type { APIRoute } from "astro";
import { db, Comment, eq } from 'astro:db';

export const DELETE: APIRoute = async (ctx) => {
  await db.delete(Comment).where(eq(Comment.id, ctx.params.id ));
  return new Response(null, { status: 204 });
}

Consulta la referencia de la API delete() de Drizzle para una descripción completa.

Filtrado

Para consultar resultados de tabla por una propiedad específica, usa opciones de Drizzle para selecciones parciales. Por ejemplo, agrega una llamada .where() a tu consulta select() y pasa la comparación que quieres hacer.

El siguiente ejemplo consulta todas las filas en una tabla Comment que contengan la frase “Astro DB”. Usa el operador like() para verificar si una frase está presente dentro del body:

---
import { db, Comment, like } from 'astro:db';

const comments = await db.select().from(Comment).where(
    like(Comment.body, '%Astro DB%')
);
---

Utilidades de Drizzle

Todas las utilidades de Drizzle para construir consultas están expuestas desde el módulo astro:db. Esto incluye:

Operadores de filtro como eq() y gt()
Ayudantes de agregación como count()
El ayudante sql para escribir consultas SQL crudas

import { eq, gt, count, sql } from 'astro:db';

Relaciones

Puedes consultar datos relacionados desde múltiples tablas usando un join de SQL. Para crear una consulta de join, extiende tu sentencia db.select() con un operador de join. Cada función acepta una tabla con la que unir y una condición para emparejar filas entre las dos tablas.

Este ejemplo usa una función innerJoin() para unir autores de Comment con su información de Author relacionada basada en la columna authorId. Esto devuelve un arreglo de objetos con cada fila de Author y Comment como propiedades de primer nivel:

---
import { db, eq, Comment, Author } from 'astro:db';

const comments = await db.select()
  .from(Comment)
  .innerJoin(Author, eq(Comment.authorId, Author.id));
---

<h2>Comentarios</h2>

{
  comments.map(({ Author, Comment }) => (
    <article>
      <p>Autor: {Author.name}</p>
      <p>{Comment.body}</p>
    </article>
  ))
}

Consulta la referencia de join de Drizzle para todos los operadores de join y opciones de configuración disponibles.

Transacciones por Lotes

Todas las consultas a bases de datos remotas se realizan como una solicitud de red. Es posible que necesites “agrupar” consultas juntas en una sola transacción cuando hagas un gran número de consultas, o para tener reversiones automáticas si falla alguna consulta.

Este ejemplo siembra múltiples filas en una sola solicitud usando el método db.batch():

import { db, Author, Comment } from 'astro:db';

export default async function () {
  const queries = [];
  // Siembra 100 comentarios de ejemplo en tu base de datos remota
  // con una sola solicitud de red.
  for (let i = 0; i < 100; i++) {
    queries.push(db.insert(Comment).values({ body: `Comentario de prueba ${i}` }));
  }
  await db.batch(queries);
}

Consulta la documentación de db.batch() de Drizzle para más detalles.

Empujando cambios a tu base de datos

Puedes empujar cambios realizados durante el desarrollo a tu base de datos.

Empujando esquemas de tabla

Tu esquema de tabla puede cambiar con el tiempo a medida que tu proyecto crece. Puedes probar de manera segura cambios de configuración localmente y empujar a tu base de datos remota cuando despliegues.

Puedes empujar tus cambios de esquema local a tu base de datos remota a través de la CLI usando el comando astro db push --remote:

npm run astro db push --remote

pnpm astro db push --remote

yarn astro db push --remote

Este comando verificará que tus cambios locales se pueden realizar sin pérdida de datos y, si es necesario, sugerirá cómo hacer cambios en tu esquema de manera segura para resolver conflictos.

Empujando cambios de esquema que rompen compatibilidad

Si debes cambiar tu esquema de tabla de una manera que es incompatible con tus datos existentes alojados en tu base de datos remota, necesitarás resetear tu base de datos de producción.

Para empujar una actualización de esquema de tabla que incluya un cambio que rompe compatibilidad, agrega la bandera --force-reset para resetear todos los datos de producción:

npm run astro db push --remote --force-reset

pnpm astro db push --remote --force-reset

yarn astro db push --remote --force-reset

Renombrando tablas

Es posible renombrar una tabla después de haber empujado tu esquema a tu base de datos remota.

Si no tienes datos de producción importantes, entonces puedes resetear tu base de datos usando la bandera --force-reset. Esta bandera eliminará todas las tablas de la base de datos y creará nuevas para que coincida exactamente con tu esquema actual.

Para renombrar una tabla mientras preservas tus datos de producción, debes realizar una serie de cambios no destructivos para empujar tu esquema local a tu base de datos remota de manera segura.

El siguiente ejemplo renombra una tabla de Comment a Feedback:

En tu archivo de configuración de base de datos, agrega la propiedad deprecated: true a la tabla que quieres renombrar:

const Comment = defineTable({
  deprecated: true,
  columns: {
    author: column.text(),
    body: column.text(),
  }
});

Agrega un nuevo esquema de tabla (coincidiendo exactamente con las propiedades de la tabla existente) con el nuevo nombre:

const Comment = defineTable({
  deprecated: true,
  columns: {
    author: column.text(),
    body: column.text(),
  }
});
const Feedback = defineTable({
  columns: {
    author: column.text(),
    body: column.text(),
  }
});

Empuja a tu base de datos remota con astro db push --remote. Esto agregará la nueva tabla y marcará la antigua como obsoleta.
Actualiza cualquier código de tu proyecto local para usar la nueva tabla en lugar de la antigua. Es posible que también necesites migrar datos a la nueva tabla.

Una vez que estés seguro de que la tabla antigua ya no se usa en tu proyecto, puedes eliminar el esquema de tu config.ts:

const Comment = defineTable({
  deprecated: true,
  columns: {
    author: column.text(),
    body: column.text(),
  }
});

const Feedback = defineTable({
  columns: {
    author: column.text(),
    body: column.text(),
  }
});

Empuja a tu base de datos remota nuevamente con astro db push --remote. La tabla antigua será eliminada, dejando solo la nueva tabla renombrada.

Empujando datos de tabla

Es posible que necesites empujar datos a tu base de datos remota para sembrar o migraciones de datos. Puedes crear un archivo .ts con el módulo astro:db para escribir consultas con seguridad de tipos. Luego, ejecuta el archivo contra tu base de datos remota usando el comando astro db execute <ruta-del-archivo> --remote:

Los siguientes Comentarios se pueden sembrar usando el comando astro db execute db/seed.ts --remote:

import { Comment } from 'astro:db';

export default async function () {
  await db.insert(Comment).values([
    { authorId: 1, body: '¡Espero que te guste Astro DB!' },
    { authorId: 2, body: '¡Disfrútalo!' },
  ])
}

Consulta la referencia de la CLI (EN) para una lista completa de comandos.

Construyendo integraciones de Astro DB

Las integraciones de Astro (EN) pueden extender proyectos de usuario con tablas adicionales de Astro DB y datos de semilla.

Usa el método extendDb() en el hook astro:db:setup para registrar configuraciones adicionales de Astro DB y archivos de semilla. El ayudante defineDbIntegration() proporciona soporte de TypeScript y autocompletado para el hook astro:db:setup.

import { defineDbIntegration } from '@astrojs/db/utils';

export default function MyIntegration() {
  return defineDbIntegration({
    name: 'mi-integracion-impulsada-por-astro-db',
    hooks: {
      'astro:db:setup': ({ extendDb }) => {
        extendDb({
          configEntrypoint: '@astronaut/my-package/config',
          seedEntrypoint: '@astronaut/my-package/seed',
        });
      },
      // Otros hooks de integración...
    },
  });
}

Los archivos de configuración y semilla de integración siguen el mismo formato que sus equivalentes definidos por el usuario.

Operaciones con seguridad de tipos en integraciones

Mientras trabajas en integraciones, es posible que no puedas beneficiarte de los tipos de tabla generados por Astro exportados desde astro:db. Para seguridad de tipos completa, usa la utilidad asDrizzleTable() para crear un objeto de referencia de tabla que puedas usar para operaciones de base de datos.

Por ejemplo, dada una integración configurando la siguiente tabla de base de datos Pets:

import { defineDb, defineTable, column } from 'astro:db';

export const Pets = defineTable({
  columns: {
    name: column.text(),
    species: column.text(),
  },
});

export default defineDb({ tables: { Pets } });

El archivo de semilla puede importar Pets y usar asDrizzleTable() para insertar filas en tu tabla con verificación de tipos:

import { asDrizzleTable } from '@astrojs/db/utils';
import { db } from 'astro:db';
import { Pets } from './config';

export default async function() {
  const typeSafePets = asDrizzleTable('Pets', Pets);

  await db.insert(typeSafePets).values([
    { name: 'Palomita', species: 'cat' },
    { name: 'Pan', species: 'dog' },
  ]);
}

El valor devuelto por asDrizzleTable('Pets', Pets) es equivalente a import { Pets } from 'astro:db', pero está disponible incluso cuando la generación de tipos de Astro no puede ejecutarse. Puedes usarlo en cualquier código de integración que necesite consultar o insertar en la base de datos.

Migrar de Astro Studio a Turso

En el panel de control de Studio, navega al proyecto que deseas migrar. En la pestaña de configuración, usa el botón “Exportar Base de Datos” para descargar un volcado de tu base de datos.
Sigue las instrucciones oficiales para instalar la CLI de Turso y registrarte o iniciar sesión en tu cuenta de Turso.
Crea una nueva base de datos en Turso usando el comando turso db create.
Ventana de terminal
```
turso db create [nombre-de-la-base-de-datos]
```
Obtén la URL de la base de datos usando la CLI de Turso, y úsala como la variable de entorno ASTRO_DB_REMOTE_URL.
Ventana de terminal
```
turso db show [nombre-de-la-base-de-datos]
```
```
ASTRO_DB_REMOTE_URL=[tu-url-de-base-de-datos]
```
Crea un token para acceder a tu base de datos, y úsalo como la variable de entorno ASTRO_DB_APP_TOKEN.
Ventana de terminal
```
turso db tokens create [nombre-de-la-base-de-datos]
```
```
ASTRO_DB_APP_TOKEN=[tu-token-de-aplicación]
```
Empuja tu esquema de DB y metadatos a la nueva base de datos de Turso.
Ventana de terminal
```
astro db push --remote
```
Importa el volcado de base de datos del paso 1 en tu nueva DB de Turso.
Ventana de terminal
```
turso db shell [nombre-de-la-base-de-datos] < ./ruta/al/volcado.sql
```
Una vez que hayas confirmado que tu proyecto se conecta a la nueva base de datos, puedes eliminar de manera segura el proyecto de Astro Studio.

Contribuir Comunidad Patrocinador