Testare e distribuire da CI

aura functions serve esegue il tuo file con Deno e lo riavvia quando lo salvi.

aura functions serve hello --port 54321
curl -X POST http://127.0.0.1:54321/ -H 'Content-Type: application/json' -d '{"name":"Ada"}'

È un semplice server Deno. Rispetto alla piattaforma ha:

• Nessuna intestazione della piattaforma. x-aura-role e x-aura-user-id sono assenti: inviateli tu stesso con curl -H per testare i rami di autorizzazione.
• Nessun segreto. Passali nella tua shell: STRIPE_SECRET_KEY=sk_test_… aura functions serve checkout.
• Nessun limite. I limiti di memoria, timeout, dimensione corporea e frequenza non vengono applicati.
• Richieste semplici. Chiami direttamente la funzione, quindi path e method sono quelle del tuo curl, non le opzioni invoke dell'SDK.

L'SDK non può avere come destinazione questo server perché invoke chiama la route della piattaforma. Testa il percorso dell'SDK rispetto a un progetto reale, come di seguito.

Crea un progetto per lo sviluppo (vedi la tua prima funzione), distribuisci lì la funzione ed esegui il test tramite l'SDK. Ciò copre le intestazioni di identità, i limiti e le classi di errore della piattaforma.

import { createClient, FunctionsHttpError } from '@aurabase/aurabase-js'
import { describe, expect, it } from 'vitest'

const aura = createClient(process.env.AURA_TEST_URL!, process.env.AURA_TEST_ANON_KEY!)

describe('hello', () => {
  it('greets', async () => {
    const { data, error } = await aura.functions.invoke<{ greeting: string }>('hello', { body: { name: 'Ada' } })
    expect(error).toBeNull()
    expect(data?.greeting).toBe('Hello, Ada!')
  })

  it('reports a missing function as a FunctionsHttpError 404', async () => {
    const { error } = await aura.functions.invoke('does-not-exist')
    expect(error).toBeInstanceOf(FunctionsHttpError)
    expect(error?.status).toBe(404)
  })

  it('refuses to list functions with a public key', async () => {
    const { data, error } = await aura.functions.list()
    expect(data).toBeNull()
    expect(error?.status).toBe(403)
  })
})

Suggerimenti:

• Utilizza un progetto dedicato, mai la produzione, e mantieni le sue chiavi nei tuoi segreti CI.
• Il limite della velocità di chiamata è di 15 chiamate, quindi 1 al secondo per IP. Distanzia i tuoi test o eseguili in serie.

La CLI aura si installa da npm su macOS Apple Silicon e dal sorgente altrove, quindi un lavoro CI Linux è più semplice con l'API HTTP. La distribuzione prevede un POST per funzione, autenticato con una chiave service_role. Questo ciclo esatto è stato eseguito su un progetto reale e la funzione ha risposto successivamente.

name: Deploy functions
on:
  push:
    branches: [main]
    paths: ['aurabase/functions/**']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy every function
        env:
          AURA_PROJECT_URL: ${{ secrets.AURA_PROJECT_URL }}
          AURA_SERVICE_ROLE_KEY: ${{ secrets.AURA_SERVICE_ROLE_KEY }}
        run: |
          set -euo pipefail
          for dir in aurabase/functions/*/; do
            name=$(basename "$dir")
            file="${dir}index.ts"
            [ -f "$file" ] || continue
            jq -n --arg name "$name" --rawfile code "$file" \
              '{name: $name, runtime: "deno", code: $code}' |
            curl -sS --fail-with-body -X POST "$AURA_PROJECT_URL/v1/functions" \
              -H "apikey: $AURA_SERVICE_ROLE_KEY" \
              -H "Content-Type: application/json" \
              --data-binary @-
            echo " deployed $name"
          done

Fatti che rendono sicuro l'esecuzione ad ogni spinta:

• POST sostituisce il codice di una funzione esistente e mantiene i suoi segreti, perché il corpo non ha env_vars.
• Una funzione è a file singolo: le relative importazioni non vengono spedite. Raggruppa prima se usi i moduli locali.
• Non c'è cronologia delle versioni sul server. La cronologia Git è il rollback: per tornare indietro, annullare il commit e consentire nuovamente la distribuzione di CI.

Quindi esegui i test di integrazione rispetto al progetto appena distribuito, in un lavoro successivo.

Un progetto è un ambiente. Crea un progetto per ambiente, ciascuno con il proprio URL e chiavi, e lascia che CI scelga la destinazione:

Archivia AURA_PROJECT_URL e AURA_SERVICE_ROLE_KEY per ambiente GitHub e imposta i segreti di ciascuna funzione separatamente in ciascun progetto. Nulla è condiviso tra i progetti.