Test en implementeer vanuit CI

aura functions serve voert uw bestand uit met Deno en start het opnieuw wanneer u het opslaat.

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

Het is een gewone Deno-server. Vergeleken met het platform heeft het:

• Geen platformheaders. x-aura-role en x-aura-user-id ontbreken: stuur ze zelf met curl -H om autorisatievertakkingen te testen.
• Geen geheimen. Geef ze door in je shell: STRIPE_SECRET_KEY=sk_test_… aura functions serve checkout.
• Geen limieten. Geheugen-, time-out-, lichaamsgrootte- en snelheidslimieten worden niet toegepast.
• Duidelijke verzoeken. U roept de functie rechtstreeks aan, dus path en method zijn die van uw curl en niet de invoke-opties van de SDK.

De SDK kan deze server niet targeten, omdat invoke de platformroute aanroept. Test het SDK-pad met een echt project, zoals hieronder.

Maak een project voor ontwikkeling (zie uw eerste functie), implementeer de functie daar en test via de SDK. Dit omvat de identiteitsheaders, limieten en foutklassen van het platform.

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)
  })
})

Tips:

• Gebruik een specifiek project, nooit productie, en bewaar de sleutels ervan in uw CI-geheimen.
• De limiet voor de aanroepsnelheid is 15 oproepen en vervolgens 1 per seconde per IP. Verspreid uw tests of voer ze serieel uit.

De aura CLI wordt geïnstalleerd vanaf npm op macOS Apple Silicon en vanaf een andere bron, dus een Linux CI-taak is eenvoudiger met de HTTP API. Implementatie is één POST per functie, geverifieerd met een service_role sleutel. Deze exacte lus werd tegen een echt project uitgevoerd en de functie antwoordde daarna.

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

Feiten die ervoor zorgen dat dit bij elke druk veilig is:

• De POST vervangt de code van een bestaande functie en behoudt zijn geheimen, omdat de body geen env_vars heeft.
• Een functie bestaat uit één bestand: relatieve importen worden niet verzonden. Bundel eerst als u lokale modules gebruikt.
• Er is geen versiegeschiedenis op de server. Je Git-geschiedenis is de rollback: om terug te gaan, draai je de commit terug en laat je CI opnieuw implementeren.

Voer vervolgens uw integratietests uit op het project dat u zojuist hebt geïmplementeerd, in een volgende taak.

Eén project is één omgeving. Creëer één project per omgeving, elk met een eigen URL en sleutels, en laat CI het doel kiezen:

Bewaar AURA_PROJECT_URL en AURA_SERVICE_ROLE_KEY per GitHub-omgeving en stel de geheimen van elke functie afzonderlijk in elk project in. Er wordt niets gedeeld tussen projecten.