0Pricing
Supabase Backend as a Service · Lekcja

Wdrażanie pierwszej funkcji

Napisz i wdroż prostą Edge Function obsługującą niestandardowe endpointy API lub logikę backendu bezpośrednio z projektu Supabase.

Wdrażanie pierwszej funkcji to bezpłatna lekcja Supabase Backend as a Service na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Supabase Backend as a Service, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Supabase Backend as a Service zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Making Your Code Go Live

Welcome to deploying your first Supabase Edge Function! This lesson will guide you through taking your function code and making it accessible via an API endpoint.

Deploying means publishing your function so it can be called from your app, a web browser, or other services. It's how your backend logic goes live!

The Supabase CLI

To deploy Edge Functions, you'll primarily use the Supabase Command Line Interface (CLI). This tool helps you manage your Supabase project locally and interact with your remote backend.

  • Ensure the CLI is installed and configured for your project.
  • You'll use commands like supabase functions new and supabase functions deploy.

Creating a New Function

Let's start by creating a new Edge Function. Navigate to your project's root directory in your terminal and use the supabase functions new command:

This command creates a new folder for your function with an index.ts file, which is where your Deno (TypeScript/JavaScript) code will live.

supabase functions new my-first-function

Function Code Structure

After creating the function, you'll find a new directory (e.g., supabase/functions/my-first-function) containing an index.ts file. This file is the entry point for your Edge Function.

Supabase Edge Functions are built on Deno, a secure runtime for JavaScript and TypeScript. They export a default function that handles incoming HTTP requests.

Writing a Simple Function

Now, let's write a basic 'Hello, World!' function. Open the index.ts file inside your new function's directory and replace its content with the following code:

This function simply returns a plain text response. It's a great starting point!

import { serve } from 'https://deno.land/std@0.177.0/http/server.ts'

serve(async (req) => {
  return new Response("Hello from your first Edge Function!", {
    headers: { 'Content-Type': 'text/plain' },
  })
})

Deploying Your Function

With your code ready, it's time to deploy! Use the supabase functions deploy command, specifying your function's name:

The CLI will build your function and upload it to your Supabase project. Once deployed, it becomes a live API endpoint!

supabase functions deploy my-first-function

Invoking with cURL

After deployment, you can test your function. The easiest way is using cURL in your terminal. You'll need your Supabase project URL and your project's Anon Key (found in your project settings).

Replace the placeholders with your actual project details:

curl -X POST 'https://your-project-ref.supabase.co/functions/v1/my-first-function' \
  -H 'Authorization: Bearer YOUR_ANON_KEY' \
  -H 'Content-Type: application/json' \
  -d '{}'

Invoking from Web (JS)

You can also call your Edge Function from any web application using standard fetch API. Here's how you might invoke it from client-side JavaScript:

Remember to replace the placeholder URL and key with your actual project details.

async function callMyFunction() {
  const SUPABASE_URL = "https://your-project-ref.supabase.co";
  const SUPABASE_ANON_KEY = "YOUR_ANON_KEY";

  try {
    const res = await fetch(
      `${SUPABASE_URL}/functions/v1/my-first-function`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${SUPABASE_ANON_KEY}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({})
      }
    )
    const data = await res.text() // Use .text() for plain text response
    console.log(data)
  } catch (error) {
    console.error("Error calling function:", error)
  }
}

callMyFunction()

Passing Data & Redeploying

Functions are more useful when they can accept input! Let's update our function to take a name from the request body and respond with a personalized greeting.

After modifying the index.ts file, you'll need to run supabase functions deploy my-first-function again to push the changes live.

import { serve } from 'https://deno.land/std@0.177.0/http/server.ts'

serve(async (req) => {
  const { name } = await req.json() // Expects { "name": "..." }
  const greeting = name ? `Hello, ${name}!` : "Hello there!"

  return new Response(
    JSON.stringify({ message: greeting }),
    { headers: { 'Content-Type': 'application/json' } },
  )
})

Quick Check: Deployment Steps

Which of the following is the correct sequence of steps to deploy a Supabase Edge Function after writing its code?

Recap: Your First Deployment!

You've successfully deployed your first Supabase Edge Function! Here's what we covered:

  • Used the Supabase CLI to manage functions.
  • Created a new function with supabase functions new.
  • Wrote a simple Deno function in index.ts.
  • Deployed it using supabase functions deploy.
  • Invoked the function using cURL and client-side JavaScript.
  • Learned to pass data to functions and redeploy changes.

Now you have a live backend endpoint ready for action!

Często zadawane pytania

Czy lekcja „Wdrażanie pierwszej funkcji” jest bezpłatna?

Tak — pełny tekst „Wdrażanie pierwszej funkcji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Supabase Backend as a Service, przejdź na CoddyKit PRO. Kurs Supabase Backend as a Service zawiera 4 lekcji w sumie.

Co nauczysz się w „Wdrażanie pierwszej funkcji”?

Napisz i wdroż prostą Edge Function obsługującą niestandardowe endpointy API lub logikę backendu bezpośrednio z projektu Supabase. Ćwiczysz Supabase Backend as a Service z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Supabase Backend as a Service?

Nie wymagamy żadnego doświadczenia. Supabase Backend as a Service w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Wdrażanie pierwszej funkcji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Supabase Backend as a Service?

Tak. Każda lekcja Supabase Backend as a Service zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wprowadzenie do Edge Functions
  2. Wdrażanie pierwszej funkcji
  3. Integracja funkcji z aplikacją
  4. Sekrety, zmienne środowiskowe i funkcje harmonogramowane
← Powrót do Supabase Backend as a Service