Cosa sono le funzioni serverless?

In questo articolo parleremo di serverless computing, delle varie architetture software, delle funzioni serverless, dei loro vantaggi e dei casi d’uso. Nella seconda parte dell’articolo, impareremo a costruire un backend serverless su Back4app utilizzando le funzioni di Cloud Code.

Che cos’è una funzione serverless?

Una funzione serverless è un pezzo di codice guidato dagli eventi che ha un unico scopo. Può essere attivata da eventi specifici come richieste HTTP, modifiche al database o altri messaggi. Queste funzioni sono scritte da uno sviluppatore di software e successivamente distribuite nel cloud. Il cloud provider gestisce quindi l’infrastruttura, la sicurezza, si occupa dell’esecuzione del codice e scala automaticamente le risorse in base alla domanda.

Le funzioni serverless sono spesso confuse con l’informatica serverless. Sebbene i termini siano correlati tra loro, non possono essere utilizzati in modo intercambiabile. Il serverless computing è un modello di cloud computing in cui i cloud provider gestiscono l’infrastruttura necessaria per l’esecuzione delle applicazioni, mentre le funzioni serverless sono un tipo di serverless computing che consente agli sviluppatori di eseguire e distribuire facilmente piccole parti di codice nel cloud.

Come funzionano le funzioni serverless?

La maggior parte delle applicazioni moderne si divide in due parti: il frontend e il backend. Il frontend è ciò che l’utente vede e con cui può interagire, mentre il backend è tutto ciò che l’utente non può vedere. Questo include la logica aziendale, l’archiviazione dei dati, i database, le API e così via.

Le funzioni serverless semplificano la componente backend delle applicazioni software, suddividendo il backend in più funzioni riutilizzabili a scopo singolo. Queste funzioni possono essere successivamente collegate per eseguire compiti complessi.

Il modo più semplice per comprendere le funzioni serverless è quello di guardare a un esempio reale. Supponiamo di avere un negozio di e-commerce in cui un utente può visualizzare i prodotti, aggiungerli al carrello, rimuoverli dal carrello ed effettuare il checkout.

Il nostro backend serverless includerà probabilmente le seguenti funzioni:

getProductList()                       -> retrieves the products from the database
getProduct(productId)                  -> retrieves a specific product from the database
getCart(user)                          -> returns the products in the user's cart
addToCart(user, productId)             -> adds a product to the user's cart
removeFromCart(user, productId)        -> removes the product from the user's cart
clearCart(user)                        -> clears user's cart

E poi abbiamo anche funzioni più complesse che utilizzano altre funzioni serverless:

checkout()
    cart = getCart(user)
    finalizeCheckout(user, cart)       -> deducts money from user's account
    clearCart(user)
    sendConfirmationEmail(user, cart)  -> sends a confirmation email to the user

Ok, ma come funzionano le funzioni serverless sotto il cofano?

Le funzioni serverless funzionano sfruttando la tecnologia di containerizzazione, che prevede l’impacchettamento del codice in contenitori leggeri e isolati che possono essere facilmente distribuiti e scalati su richiesta. Quando viene attivata una funzione serverless, il cloud provider crea una nuova istanza del contenitore, vi esegue il codice e lo chiude al termine dell’esecuzione.

Il fornitore di cloud in genere gestisce tutti gli aspetti della gestione dell’infrastruttura sottostante, compresi il ridimensionamento, il bilanciamento del carico e l’allocazione delle risorse, quindi gli sviluppatori non devono preoccuparsi di configurare o gestire i server. Invece, gli sviluppatori devono semplicemente scrivere il codice, caricarlo sul cloud provider e definire le condizioni di attivazione per l’esecuzione del codice.

Quali sono le diverse architetture software?

Oltre alle funzioni serverless, abbiamo anche l’architettura monolitica e l’architettura a microservizi. Esaminiamole.

Architettura monolitica

In un’architettura monolitica, l’applicazione è costruita come una singola unità con tutti i componenti strettamente integrati. Tutte le funzionalità sono riunite in un’unica base di codice e l’applicazione viene distribuita come un unico pacchetto. L’architettura monolitica è semplice da costruire e mantenere, ma può diventare complessa e difficile da scalare quando l’applicazione cresce.

Architettura a microservizi

L’architettura a microservizi è un approccio alla costruzione di applicazioni software come un insieme di piccoli servizi indipendenti che comunicano tra loro tramite API. Ogni microservizio è responsabile di una funzione specifica dell’applicazione e può essere sviluppato, distribuito e scalato in modo indipendente. Questo approccio consente una maggiore flessibilità, scalabilità e resilienza, ma può anche introdurre complessità in termini di comunicazione e gestione dei servizi.

In conclusione, le applicazioni monolitiche sono più adatte a progetti più semplici che non richiedono di scalare molto. D’altro canto, i microservizi e i serverless sono generalmente più adatti a progetti più complessi che devono essere altamente scalabili e flessibili. Oltre a tutti i vantaggi dei microservizi, l’architettura serverless astrae anche dalla gestione dell’infrastruttura. Pertanto, consente di risparmiare molto tempo e denaro.

Quali sono i vantaggi delle funzioni serverless?

Le funzioni come servizio (FaaS) offrono molti vantaggi.

Sviluppo più rapido

Le funzioni serverless consentono uno sviluppo e una distribuzione più rapidi, poiché non è necessario gestire l’infrastruttura, configurare i server, impostare lo scaling o gestire i server. Poiché le funzioni serverless sono piccole porzioni di codice che servono a un unico scopo, possono essere facilmente testate e sottoposte a debug. Inoltre, le funzioni serverless possono essere facilmente integrate con altri servizi cloud o API di terze parti, eliminando molti problemi comuni.

Elevata scalabilità e disponibilità

Le funzioni serverless possono gestire un gran numero di richieste e scalare automaticamente in base alla domanda. Questo garantisce che l’applicazione possa gestire qualsiasi livello di traffico. Inoltre, se nessuno utilizza il vostro servizio, l’ambiente può scalare fino a zero, risparmiando molto denaro.

È anche possibile distribuire le funzioni come servizio (FaaS) in più zone. Questo può aiutarvi a migliorare la disponibilità della vostra applicazione distribuendo le vostre funzioni in tutto il mondo.

Maggiore flessibilità

Le funzioni serverless consentono agli sviluppatori di scegliere il linguaggio di programmazione e gli strumenti più adatti alle loro esigenze. La maggior parte dei fornitori di serverless supporta diversi linguaggi come JavaScript, Java, Python, Go e .NET. Questo garantisce una maggiore flessibilità nello sviluppo e nella distribuzione delle applicazioni.

Costo-efficacia

Serverless è l’architettura più efficace dal punto di vista dei costi, poiché si paga solo ciò che si consuma. Ovvero il runtime delle funzioni e gli altri servizi gestiti che le funzioni utilizzano. Inoltre, non è necessario pagare per le risorse inattive.

Quali sono alcuni dei casi d’uso delle funzioni serverless?

Le funzioni serverless possono essere utilizzate praticamente in qualsiasi progetto. È possibile utilizzare le funzioni serverless per costruire il progetto dalle fondamenta o solo per compiti specifici. I principali casi d’uso includono:

• Applicazioni web
• Creare API RESTful
• Attività basate su trigger
• Automazione delle attività programmate
• Elaborazione asincrona
• Internet degli oggetti (IoT)
• CI/CD

La maggior parte dei team di sviluppatori migra a serverless per gradi. Migrano attività per attività fino a quando non c’è più bisogno di server tradizionali.

Quali sono gli esempi di ambienti serverless?

Piattaforma come servizio (PaaS)

Platform as a Service (PaaS) è una soluzione vantaggiosa di cloud computing che offre agli utenti la possibilità di creare, gestire e distribuire applicazioni in un ambiente basato sul cloud.

Fornisce strumenti preconfigurati per lo sviluppo, la personalizzazione e il test delle applicazioni, eliminando gran parte del tempo dedicato alla gestione dell’infrastruttura.

Lo sviluppo di un’applicazione che verrà distribuita su PaaS non è molto diverso dalla creazione di un’applicazione tradizionale. I fornitori di PaaS non supportano le funzioni serverless in modo immediato.

I servizi PaaS includono: Heroku, AWS Elastic Beanstalk, DigitalOcean App Platform e Fly.io.

Backend come servizio (BaaS)

BaaS snellisce e semplifica lo sviluppo del backend fornendo una piattaforma per la gestione dell’infrastruttura cloud.

Gestisce tutte le noiose attività associate alla creazione di un backend, consentendo agli sviluppatori di concentrarsi sulla creazione di applicazioni. Automatizzando molti di questi processi, BaaS aiuta gli sviluppatori a creare applicazioni robuste in modo rapido ed efficiente.

La piattaforma offre un’ampia gamma di funzionalità, tra cui la gestione degli utenti, le notifiche, le integrazioni con i social media e l’archiviazione. Si tratta quindi di una scelta ideale per le aziende che desiderano sviluppare la propria presenza digitale. Inoltre, offre convenienza e facilità d’uso che la rendono accessibile a tutti gli utenti.

Gli sviluppatori sono liberi dalla necessità di preoccuparsi dell’infrastruttura di backend e possono invece concentrare i loro sforzi sulla creazione del frontend dei loro progetti. In questo modo possono concentrarsi sul core business senza dover dedicare tempo ed energie ad altre attività.

Alcuni fornitori di BaaS ci permettono anche di distribuire funzioni serverless:

• Back4app ha funzioni di Cloud Code
• Firebase ha le funzioni cloud di Google
• AWS Amplify dispone di AWS Lambda

Altri fornitori di BaaS sono Supabase, Kinvey e Parse.

Funzione come servizio (FaaS)

Function as a Service (FaaS) è un modello di cloud computing specializzato per le funzioni serverless. FaaS consente agli sviluppatori di concentrarsi sulla scrittura e sulla distribuzione di singole funzioni piuttosto che sulla costruzione e sulla gestione di uno stack applicativo completo. Le funzioni serverless di solito si integrano con API di terze parti e altri servizi cloud. Questo modello di elaborazione può scalare automaticamente e rapidamente per adattarsi a qualsiasi traffico.

Le principali differenze tra BaaS e FaaS risiedono in:

• Costruzione dell’applicazione
• Scalabilità
• Modello di prezzo

Le funzioni serverless vengono eseguite in container, sono più scalabili e più efficienti dal punto di vista dei costi, poiché si paga solo il tempo di esecuzione delle funzioni. D’altra parte, BaaS ha molte funzionalità integrate, come la gestione degli utenti, le notifiche push, le integrazioni con i social media e altri strumenti pronti all’uso che consentono di creare rapidamente backend. Inoltre, BaaS è estremamente facile da usare.

Alcuni esempi di FaaS sono: AWS Lambda, Google Cloud Functions e Azure Functions.

Costruire un backend serverless su Back4app

In questa sezione del tutorial, dimostreremo come codificare e distribuire le funzioni di Cloud Code su Back4app. Inoltre, impareremo a collegare un frontend a un backend serverless.

Obiettivi:

Alla fine di questo tutorial, sarete in grado di:

• Spiegare cosa sono e come funzionano le funzioni del Cloud Code
• Codificare le funzioni del Cloud Code che possono manipolare il database
• Utilizzare le funzioni di Cloud Code per recuperare i dati da API di terze parti
• Creare lavori Cloud personalizzati e pianificarli
• Collegare un progetto frontend con un backend serverless

Che cos’è Back4app?

Back4app è una piattaforma leader nel settore BaaS (Backend as a Service) che fornisce agli sviluppatori gli strumenti e le funzionalità necessarie per creare facilmente applicazioni web e mobili.

Grazie alla sua serie completa di vantaggi, consente agli sviluppatori di concentrarsi sugli aspetti principali della loro attività, invece di preoccuparsi delle complessità del backend o dei problemi di infrastruttura. È una delle soluzioni BaaS open-source più apprezzate oggi disponibili.

La soluzione completa è dotata di una dashboard interattiva e di una flessibile interfaccia a riga di comando (CLI) per la massima comodità. Inoltre, fornisce SDK compatibili con React Native, Flutter, Node.js, Angular, iOS, Android e altri ancora, rendendo semplice l’integrazione nei sistemi esistenti!

Le caratteristiche principali di Back4app comprendono un database in stile foglio di calcolo, API GraphQL e REST, query live, autenticazione con opzioni di login sociale, scalabilità per l’hosting e notifiche, tutte disponibili in questa potente piattaforma.

Per ulteriori informazioni, leggere le caratteristiche di Back4app.

Back4app offre un modello economico per tutti i tipi di app, dalle più piccole alle più grandi. Offre un piano gratuito perfetto per lo sviluppo e la sperimentazione della piattaforma.

Introduzione al progetto

Costruiremo una semplice applicazione per la gestione delle stazioni meteorologiche. Creeremo prima delle stazioni meteorologiche virtuali e poi useremo WeatherAPI per ottenere le informazioni meteo effettive nelle località in cui si trovano le stazioni. Per definire la logica dell’applicazione, utilizzeremo le funzioni di Cloud Code e i Cloud Jobs. Infine, dimostreremo come collegare facilmente un progetto frontend a un backend serverless.

Creare un’applicazione

Se non avete ancora un account Back4app, iscrivetevi subito per usufruire dei suoi servizi gratuiti. Altrimenti, accedete al vostro account esistente e procedete con i seguenti passaggi.

Per iniziare a usare Back4app, è necessario creare un’app. Accedete alla vostra dashboard per visualizzare l’elenco delle app e cliccate su “Build new app” per iniziare a creare la vostra app.

Poiché utilizzeremo il framework Parse per costruire la nostra applicazione, selezioniamo “Backend as a Service”.

Quindi, inserite un nome personalizzato per l’applicazione, selezionate “NoSQL Database” come database e infine fate clic su “Create”.

Back4app imposterà tutti i componenti necessari per la vostra applicazione, compresi il database, il livello applicativo, la scalabilità, i backup e la sicurezza. Ci vuole solo poco tempo per farlo.

Una volta completata l’applicazione, verrete reindirizzati alla dashboard della vostra applicazione.

Database

Definiamo i nostri modelli di database. Creeremo due modelli:

1. WeatherStation rappresenta una stazione meteorologica virtuale situata in una certa località.
2. WeatherRecord rappresenta una misurazione del tempo in una specifica stazione meteo.

Navigare nel “Database” e fare clic su “Crea una classe”. Nominarla WeatherStation, assicurarsi di abilitare “Public Read and Write” e aggiungere i seguenti campi:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| String                    | name            | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | location        | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Quindi, seguire gli stessi passi per creare un’altra classe chiamata WeatherRecord con i seguenti campi:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| Pointer -> WeatherStation | weatherStation  | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherText     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherIcon     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| Number                    | weatherCode     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Infine, passare al modello WeatherStation e creare due stazioni meteorologiche. Esempio:

+---------------------------+---------------+
| name                      | location      |
+---------------------------+---------------+
| Sunnyvale Station         | sunnyvale     |
+---------------------------+---------------+
| Mountain View Station     | mountain view |
+---------------------------+---------------+

Bene, questo è tutto per il database.

MeteoAPI

Per ottenere le informazioni meteo attuali, utilizzeremo un’API gratuita chiamata WeatherAPI.

Per eseguire i passaggi seguenti è necessario disporre di un account WeatherAPI. Se non ne avete ancora uno, registratevi, altrimenti accedete al vostro cruscotto.

Una volta effettuato l’accesso, prendete nota della vostra chiave API:

Quindi, aprire il terminale e cercare di ottenere le informazioni meteo attuali per “Sunnyvale” utilizzando la chiave API:

curl "https://api.weatherapi.com/v1/current.json?key=<your_api_key>&q=<location>&aqi=no"

# Example:
# curl "https://api.weatherapi.com/v1/current.json?key=354fc376a4c&q=Sunnyvale&aqi=no"

Dovreste ricevere una risposta simile a questa:

{
    "location": {
        "name": "Sunnyvale",
        "region": "California",
        "country": "United States of America",
        "lat": 37.37,
        "lon": -122.04,
    },
    "current": {
        "temp_c": 7.0,
        "temp_f": 44.6,
        "is_day": 1,
        "condition": {
            "text": "Light rain",
            "icon": "//cdn.weatherapi.com/weather/64x64/day/296.png",
            "code": 1183
        },
        ...
    }
}

Nella prossima sezione dell’articolo, utilizzeremo le funzioni di Cloud Code per recuperare le informazioni meteo dalla WeatherAPI e memorizzarle nel database.

Codice Cloud

Le funzioni Cloud Code sono una potente caratteristica di Parse Server che consente agli sviluppatori di eseguire codice JavaScript personalizzato lato server. Gli sviluppatori possono utilizzare queste funzioni per implementare la logica aziendale, convalidare i dati, elaborare dati complessi e costruire backend serverless in generale.

Accedere alla dashboard dell’applicazione Back4app e selezionare “Funzioni e Web Hosting” sotto “Codice Cloud” nella barra laterale.

L’interfaccia utente di Back4app Cloud Code è facile da usare. Sul lato sinistro dello schermo è possibile vedere la struttura delle directory. Per impostazione predefinita, sono presenti due directory:

1. cloud è una directory per tutto il codice del cloud
2. public è una cartella per i file pubblici, come immagini, fogli di stile e altro.

Sul lato destro dello schermo è presente un editor di codice integrato.

Definire le funzioni di Cloud Code

Definiamo le seguenti funzioni:

1. weatherLocations restituisce l’elenco delle stazioni meteorologiche.
2. weatherInfo restituisce le previsioni del tempo per una località specifica.

Ma prima installiamo un pacchetto di terze parti chiamato axios. Axios è un client HTTP per JavaScript basato su promesse che semplifica notevolmente l’esecuzione di richieste HTTP.

Creare un nuovo file chiamato package.json nella cartella cloud e inserirvi quanto segue:

{
  "dependencies": {
    "axios": "*"
  }
}

Quindi, definire le funzioni di Cloud Code in cloud/main.js in questo modo:

// cloud/main.js

const axios = require("axios");

// make sure to replace `<api_key>` with your actual WeatherAPI key
const WEATHER_API_BASE = "https://api.weatherapi.com/v1/current.json?key=<api_key>";

Parse.Cloud.define("weatherLocations", async (request) => {
  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  return weatherStationResults.map(result => result.get("location"))
});

Parse.Cloud.define("weatherInfo", async (request) => {
  let location = request.params.location;

  if (!location) {
    throw new Parse.Error(400, "Location not provided.");
  }

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  weatherStationQuery.equalTo("location", location);
  const weatherStationResults = await weatherStationQuery.find();

  if (weatherStationResults.length == 0) {
    throw new Parse.Error(400, "Invalid location.");
  }

  const WeatherRecord = Parse.Object.extend("WeatherRecord");
  const weatherRecordQuery = new Parse.Query(WeatherRecord);
  weatherRecordQuery.equalTo("weatherStation", weatherStationResults[0]);
  weatherRecordQuery.descending("createdAt");
  weatherRecordQuery.limit(5);
  const weatherRecordResults = await weatherRecordQuery.find();

  return weatherRecordResults;
});

Infine, fate clic su “Deploy” in basso a destra per distribuire le funzioni a Back4app.

Lavoro in cloud

I Cloud Jobs consentono agli sviluppatori di eseguire lavori in background, come l’invio di notifiche push o l’elaborazione di dati. Questi lavori sono scritti in modo simile alle funzioni di Cloud Code e possono essere programmati per essere eseguiti una tantum o in modo ricorrente.

Creiamo un lavoro Cloud che misuri il tempo di tutte le nostre stazioni meteorologiche ogni 30 minuti.

Definire il lavoro nel cloud

Selezionare “Codice Cloud” nella barra laterale e incollare il seguente codice in fondo a cloud/main.js:

// cloud/main.js

// ...

Parse.Cloud.job("weatherCapture", async (request) => {
  const {params, headers, log, message} = request;
  message("weatherCapture just started...");

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  for (let i = 0; i < weatherStationResults.length; i++) {
    let weatherStation = weatherStationResults[i];

    try {
      const response = await axios.get(
        WEATHER_API_BASE + "&q=" + weatherStation.get("location") + "&aqi=no"
      );
      const currentWeather = response.data.current.condition;
      let icon = currentWeather.icon
        .replace("//", "https://")
        .replace("64x64", "128x128");

      const WeatherRecord = Parse.Object.extend("WeatherRecord");
      const weatherRecord = new WeatherRecord();
      weatherRecord.set("weatherStation", weatherStation);
      weatherRecord.set("weatherText", currentWeather.text);
      weatherRecord.set("weatherIcon", icon);
      weatherRecord.set("weatherCode", currentWeather.code);
      weatherRecord.save();
    } catch (error) {
      throw new Parse.Error(400, error);
    }
  }

  message("weatherCapture just finished!");
});

Questo codice definisce un nuovo lavoro cloud chiamato weatherCapture. Il job esegue il loop di tutte le WeatherStation, recupera le informazioni meteo da WeatherAPI e le memorizza nel database.

Per verificare se funziona, andare su “Lavori > Tutti i lavori” nella barra laterale e provare a eseguire il lavoro. Se tutto va bene, dovrebbero esserci due nuovi WeatherRecord nel database.

Programmare il lavoro nel cloud

Programmiamo l’esecuzione del lavoro ogni 30 minuti.

Selezionate “Impostazioni app > Impostazioni server” nella barra laterale e cercate “Lavori in background”. Quindi fare clic sul pulsante “Impostazioni”:

Quindi, programmare un nuovo lavoro con i seguenti dettagli:

1. Descrizione: Misura il tempo in tutte le stazioni
2. Lavoro nel cloud: weatherCapture
3. Parametri: Lasciare vuoto
4. Orario previsto: Inizio immediato
5. Dovrebbe ripetersi? Sì
6. Frequenza: Intervallo
7. A quale intervallo si ripete? 30 minuti

Ecco fatto. Il lavoro WeatherCapture verrà eseguito ogni 30 minuti.

Il nostro backend serverless è ora pronto. Nella prossima sezione vedremo come collegare un frontend al backend serverless.

Frontend

La costruzione di un frontend personalizzato da zero è fuori dallo scopo di questo tutorial. Tuttavia, descriverò i passi fondamentali per collegare un frontend JavaScript a un backend serverless.

• Installare Parse tramite npm o yarn e importarlo.
• Inizializzare Parse in App.js o _app.js in questo modo:

import Parse from "parse/dist/parse.min.js";
    
// to get the keys navigate to your Back4app app > App Settings > Security & Keys
Parse.initialize(
  "<your_app_id>",              // replace me
  "<your_javascript_key>",      // replace me
);
Parse.serverURL = "https://parseapi.back4app.com/";

• È quindi possibile chiamare le funzioni di Cloud Code in questo modo:

const fetchWeatherLocations = async () => {
    return await Parse.Cloud.run("weatherLocations");
};

Per ulteriori informazioni, consultare la documentazione ufficiale.

Ho anche preparato un progetto di esempio per il backend della nostra stazione meteo. Il progetto è accessibile su GitHub. Il file README.md contiene tutte le informazioni necessarie per far funzionare il progetto in locale. Sentitevi liberi di creare un fork e di giocarci.

Conclusione

Il serverless computing è diventato una soluzione sempre più popolare per gli sviluppatori che vogliono creare e distribuire applicazioni senza preoccuparsi della gestione dei server.

In questo articolo abbiamo esplorato diverse architetture software, abbiamo esaminato le funzioni serverless e ne abbiamo evidenziato i vantaggi e i casi d’uso. Infine, abbiamo dimostrato come costruire un semplice backend serverless su Back4app utilizzando le funzioni di Cloud Code.

Il codice sorgente finale si trova nel repo back4app-serverless su GitHub.

Passi futuri

1. Cercate Parse Server Security per rendere più sicuro il vostro backend.
2. Date un’occhiata a The Ultimate Guide to Deploy Docker Apps per imparare a costruire e distribuire un frontend personalizzato su Back4app Containers.
3. Conoscere i trigger di Parse.

FAQ