Migra da Supabase
L'API client, le policy RLS e Edge Functions vengono trasferite. La CLI esporta i tuoi utenti Supabase con i relativi hash delle password bcrypt, ripristina un semplice pg_dump (istruzioni, corpi delle funzioni, dati COPY) e importa gli utenti: questa pagina dice esattamente cosa riporta ogni passaggio e dove si ferma.
95% uguale a Supabase#
L'API client, le policy RLS, il modello di autenticazione e l'archiviazione seguono le convenzioni di Supabase, quindi il codice dell'applicazione cambia molto poco. La tabella seguente indica cosa è uguale e cosa no.
| Caratteristica | Compatibilità | Nota |
|---|---|---|
createClient() | Lo stesso | Importa @aurabase/aurabase-js invece di @supabase/supabase-js |
.from().select() | Lo stesso | Stessa API PostgREST concatenabile |
| RLS politiche | Lo stesso | Postgres Criteri SQL. to authenticated, to anon e to service_role sono accettati come alias di aura_authenticated, aura_anon e aura_service_role. Questi ruoli vengono creati con il cluster database del progetto; su un cluster creato prima di tale modifica, scrivere i nomi dei ruoli aura_*. |
auth.uid() e auth.role() | Lo stesso | Aiutanti compatibili richiesta per richiesta |
auth.getUser() | Piccola differenza | data è l'utente (data.email); Supabase restituisce { data: { user } }. Il codice scritto come const { data: { user } } = await supabase.auth.getUser() ottiene user === undefined qui: scrivi const { data: user } = await aura.auth.getUser() |
.rpc() | Lo stesso | Stessa firma per le funzioni Postgres |
.storage.from().upload() | Lo stesso | S3-API compatibile con percorsi identici |
.channel().on("postgres_changes") | Lo stesso | Stessa superficie di acquisizione dei dati di modifica |
| Edge Functions (Deno) | Lo stesso | Tempo di esecuzione standard Deno; Deno.serve() funziona senza riscrittura |
| Ganci di autenticazione | Piccola differenza | Webhook HTTP ed endpoint dedicati |
| Chiave del ruolo del servizio | Lo stesso | Stesso ruolo, stesso ambito |
Quattro comandi, in ordine#
- Esporta —
aura migrate export-supabasescriveusers.json(utenti, hash delle password, identità OAuth) edump.sql(pg_dumpdello schema, struttura e datipublic) - Restore —
aura db restore dump.sqlriproduce il dump nel progetto collegato - Importa utenti —
aura auth import users.json; gli utenti mantengono il proprio ID e la propria password - Cutover: cambia l'URL e le chiavi nella tua app; distribuisci il tuo Edge Functions invariato
# 1. Esporta da Supabase (Impostazioni > Database > stringa di connessione, ruolo `postgres`)
aura migrate export-supabase --db-url "$SUPABASE_DB_URL" --output-dir ./supabase-export
# 2. Ripristinare lo schema e i dati nel progetto Aurabase collegato
aura link <project>
aura db restore ./supabase-export/dump.sql --dry-run # analizzare e stampare solo il piano
aura db restore ./supabase-export/dump.sql
# 3. Importa gli utenti, con i relativi hash delle password
aura auth import ./supabase-export/users.json
Ripristinare lo schema e i dati#
aura migrate export-supabase esegue pg_dump --schema=public --no-owner --no-acl --format=plain con il tuo pg_dump locale (installa gli strumenti client PostgreSQL; senza di essi, il comando stampa la riga esatta pg_dump per eseguire te stesso).
aura db restore <file.sql> legge un semplice SQL dump come fa psql: le istruzioni sono divise all'esterno di stringhe, identificatori tra virgolette, commenti e corpi tra virgolette in dollari ($$ … $$, $fn$ … $fn$), i blocchi COPY … FROM stdin vengono letti fino alla loro riga \. e psql i meta-comandi (\connect, \restrict) vengono saltati. Quindi:
- rimuove il qualificatore
public.chepg_dumpscrive, quindi le tabelle finiscono nello schema del progetto (--source-schemaper un altro schema); - salta ciò che non ha significato su Aurabase e dice perché: impostazioni della sessione (
SET,set_config),OWNER TO,GRANT/REVOKEdei ruoli Supabase,CREATE EXTENSION(le estensioni sono gestite da Aurabase),CREATE SCHEMA public; - esegue tutto il resto nell'ordine del file e si ferma al primo passaggio non riuscito con il suo numero, la sua riga di dump e l'errore. Risolvi la causa e riprendi con
--from <step>oppure passa--continue-on-errorper superare i passaggi non riusciti e ottenere l'elenco alla fine.--dry-runstampa il piano senza eseguire nulla.
Due percorsi, scelti come aura db push:
Progetto collegato, no DATABASE_URL | DATABASE_URL impostato (stringa di connessione diretta) | |
|---|---|---|
| Trasporti | Una chiamata API SQL per istruzione, convalidata dal server | Una connessione PostgreSQL |
COPY dati | Convertito in batch INSERT (500 righe) | Protocollo COPY, dati come scaricati |
Funzioni, trigger, blocchi DO | Rifiutato dall'API SQL: creali con aura db function create e aura db trigger create | Creato |
| Confine di sicurezza | La politica di isolamento del server per il progetto | Il ruolo PostgreSQL del progetto (solo il proprio database, nessun superutente, si applica la sicurezza a livello di riga) |
Sul percorso API SQL, il server rifiuta anche stringhe E'…', riferimenti ad altri schemi e, in un'istruzione, testo che assomiglia a un comando proibito, anche all'interno di una stringa letterale: una riga di dati contenente tale testo fallisce con il suo numero di passo. Usa il percorso diretto per quei dump. La stringa di connessione diretta si trova in Impostazioni › Connessione quando la distribuzione pubblica l'accesso diretto PostgreSQL.
Il ripristino viene eseguito in sequenza: viene ordinato un semplice dump SQL (tabelle, quindi dati, quindi vincoli e indici) e non ha un grafico delle dipendenze da parallelizzare. Non viene pubblicata alcuna cifra di throughput.
I riferimenti a auth.users non vengono ripristinati così come sono. Aurabase L'autenticazione non mantiene i propri utenti in una tabella auth.users, quindi una chiave esterna come REFERENCES auth.users(id) fallisce. Ripristina con --continue-on-error e mantieni le colonne user_id senza tale vincolo: gli ID utente vengono conservati dall'importazione di seguito, quindi i valori corrispondono ancora.
Utenti e password#
aura migrate export-supabase legge auth.users e auth.identities e scrive, per ciascun utente: l'originale id, l'email, email_verified, l'bcrypt hash di encrypted_password, il nome e i metadati (raw_user_meta_data e raw_app_meta_data senza i tasti provider/providers di Supabase) e le identità OAuth collegate (Google, GitHub…). Il file è leggibile solo da te: contiene gli hash delle password, eliminalo dopo l'importazione.
aura auth import users.json invia gli utenti in batch di 1.000 all'API di importazione dell'amministratore e stampa ogni riga che non viene creata (skipped quando l'e-mail o l'ID esiste già, error con il motivo). Eseguirlo nuovamente è sicuro: gli utenti esistenti non verranno mai sovrascritti.
All'accesso, Aurabase Auth verifica l'hash bcrypt, quindi lo sostituisce con un hash Argon2id: i tuoi utenti mantengono la propria password e non fanno nulla. L'importazione accetta hash bcrypt $2a$, $2b$ e $2y$ con un costo da 4 a 12 (Supabase utilizza 10) e hash Argon2id con parametri limitati; qualsiasi altro formato viene rifiutato riga per riga. Gli utenti OAuth accedono nuovamente con lo stesso provider e accedono allo stesso account.
Non riportato: MFA fattori (TOTP, telefono), sessioni attive e token di aggiornamento (ogni utente accede nuovamente), divieti, utenti solo telefono, anonimi ed eliminati (contati e segnalati dall'esportazione). Gli utenti con MFA devono registrarsi nuovamente.
Nativo Deno: zero riscritture#
Aurabase esegue un runtime Deno standard. Le tue funzioni che utilizzano Deno.serve() sono compatibili al 100% senza modifiche:
// Funzione Deno standard: funziona così com'è su Aurabase
Deno.serve(async (req) => {
const { name } = await req.json()
return new Response(
JSON.stringify({ message: `Hello ${name}!` }),
{ headers: { 'content-type': 'application/json' } }
)
})