Quickstarters
Come costruire un backend per Golang?

36min
Introduzione
In questo tutorial, imparerai come costruire e testare un backend completo per Golang utilizzando Back4App. 
Ti guideremo nell'integrazione delle funzionalità essenziali di Back4App—come la gestione del database, le impostazioni di sicurezza, l'autenticazione degli utenti, l'archiviazione dei file e il Cloud Code—per creare un backend sicuro, flessibile e scalabile che funzioni bene con il tuo server http Go. 
Il nostro obiettivo sarà utilizzare le API RESTful di Back4App per connetterci al database dal nostro client http Golang, piuttosto che un SDK Parse dedicato, in modo da illustrare come costruire funzioni di gestione facili da mantenere per il tuo nuovo backend.
Vedrai come questo approccio riduce la complessità dello sviluppo rispetto alla configurazione dei propri server da zero. 
Affidandoti alle query in tempo reale di Back4App, all'archiviazione dei file e ai sistemi di autenticazione degli utenti, accelererai il processo di creazione del tuo backend. 
Alla fine, saprai come costruire un backend Golang sicuro, pianificare attività automatizzate e integrare webhook esterni. 
Sarai ben preparato per migliorare questa base in un'applicazione pronta per la produzione o aggiungere logica personalizzata secondo necessità.
Requisiti
Un account Back4App
Registrati gratuitamente qui.
Un nuovo progetto Back4App
Iniziare con Back4app﻿
Ambiente di sviluppo Go (Golang)
Assicurati di avere Go installato sul tuo computer. Puoi trovare istruzioni nella Documentazione ufficiale di Go.
Conoscenze di base del pacchetto http di Go e delle API RESTful
Familiarità con come scrivere un gestore func, analizzare i messaggi di errore, gestire le richieste post e impostare un server http localhost sarà utile.
Assicurati di avere questi requisiti in atto prima di procedere. Questa configurazione semplificherà la tua esperienza mentre scopri come costruire un backend per Golang utilizzando Back4App.
Passo 1 – Creare un Nuovo Progetto su Back4App e Connettersi
Perché un Nuovo Progetto?
Creare un nuovo progetto Back4App è il tuo primo passo. È qui che memorizzerai i dati, configurerai l'archiviazione dei file, programmerai funzioni cloud e aggiungerai attività in background. Questo progetto backend ancorerà tutti i passaggi successivi.
Accedi al tuo account Back4App.
Clicca su “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “Golang-Backend-Tutorial”).
﻿
Una volta creata, apparirà nel tuo dashboard. Questa applicazione è ora il tuo backend basato su Back4App.
Collegamento tramite REST APIs
Back4App fornisce API RESTful per creare, aggiornare e eliminare dati. In Golang, utilizzeremo il client http della libreria standard di Go per comunicare con questi endpoint.
Trova il tuo ID Applicazione e Chiave API REST andando alla sezione Impostazioni o Sicurezza e Chiavi della tua app Back4App:
﻿
Avrai bisogno di queste credenziali in ogni intestazione della richiesta. Illustreremo questo nei prossimi passaggi quando ci connetteremo al database utilizzando il metodo post, GET e altre richieste HTTP.
Passo 2 – Configurazione del Database
Creazione di un Modello di Dati
Per memorizzare i dati in Back4App, definisci classi (tabelle) e colonne (campi). Ad esempio, supponiamo di voler creare una Todo classe. Puoi crearla manualmente nel Dashboard di Back4App:
Vai alla sezione Database nel dashboard della tua app.
Crea una nuova classe chiamata “Todo.”
Aggiungi colonne come titolo (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Puoi anche lasciare che il sistema crei automaticamente colonne inviando oggetti con nuovi campi dalla tua applicazione Golang.
Creare un modello di dati utilizzando l'agente AI
Apri l'agente AI nel tuo cruscotto dell'app.
Descrivi il tuo modello di dati desiderato (ad es., “Per favore crea una nuova classe Todo con un campo titolo e un campo isCompleted.”).
Accetta lo schema suggerito.
﻿
Questa comoda funzione fa risparmiare tempo nella progettazione dello schema del tuo database.
Lettura e Scrittura di Dati Utilizzando REST API (Esempio in Golang)
Di seguito è riportato un esempio di base su come creare (metodo POST) e recuperare (metodo GET) dati utilizzando il pacchetto http di Go. Supponi di avere il tuo APPLICATION_ID e REST_API_KEY come variabili d'ambiente.
Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
﻿
In questi esempi, creiamo un client http, aggiungiamo le intestazioni necessarie e gestiamo i codici di risposta insieme ai messaggi di errore. Ricorda di sostituire YOUR_APPLICATION_ID e YOUR_REST_API_KEY con le chiavi effettive del tuo progetto Back4App.
Lettura e Scrittura dei Dati Utilizzando l'API GraphQL
Back4App fornisce anche un endpoint GraphQL su https://parseapi.back4app.com/graphql. Puoi utilizzare una popolare libreria client Go GraphQL (come Machine Box graphql) per eseguire query o mutazioni. Questo può essere un approccio più strutturato rispetto alle chiamate REST raw.
Lavorare con le Query Live (Opzionale)
Se desideri vedere aggiornamenti in tempo reale nella tua app, puoi abilitare le Query Live nel Dashboard di Back4App. Golang non ha una libreria ufficiale per le Query Live di Parse. Tuttavia, puoi implementare la tua connessione websocket per ascoltare gli aggiornamenti delle Query Live da wss://YOUR_SUBDOMAIN.b4a.io. Questa funzionalità è utile per app collaborative che richiedono una sincronizzazione immediata dei dati.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Panoramica
Back4App fornisce elenchi di controllo degli accessi (ACL) e permessi a livello di classe (CLP) per proteggere i tuoi dati. Gli ACL sono definiti su ciascun oggetto, mentre i CLP definiscono regole generali per un'intera classe.
﻿
Permessi a livello di classe
Vai alla visualizzazione del database della tua app in Back4App.
Seleziona una classe (ad es., Todo).
Clicca su Permessi a livello di classe e imposta l'accesso in lettura/scrittura per diversi ruoli utente o accesso pubblico.
﻿
ACL
Puoi passare un ACL quando crei o aggiorni un oggetto tramite chiamate REST. Questo garantisce che solo determinati utenti o ruoli possano leggere/scrivere i dati. Per ulteriori dettagli, visita Linee guida sulla sicurezza dell'app.
Passo 4 – Scrivere funzioni di Cloud Code
Perché Cloud Code
Il Cloud Code ti consente di eseguire funzioni lato server, trigger o validazioni—senza gestire i tuoi server. Puoi aggiungere logica aziendale avanzata o integrare API esterne dal lato server.
Esempio di funzione Cloud
Un semplice esempio è una funzione che calcola la lunghezza del testo. Nel tuo main.js file nel dashboard di Back4App:
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Distribuzione
Distribuisci il Cloud Code in uno dei seguenti modi:
Back4App CLI:
Back4App Dashboard sotto Cloud Code > Functions. Incolla il tuo codice nell' main.js editor e clicca su Distribuisci.
﻿
Chiamare le Funzioni Cloud da Golang
Puoi chiamare una Funzione Cloud tramite REST dal tuo client http:
Go
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
﻿
Passo 5 – Configurazione dell'autenticazione
Abilita l'autenticazione dell'utente
Back4App utilizza una User classe per l'autenticazione. Quando crei un nuovo utente tramite REST, il backend memorizzerà le credenziali in modo sicuro e genererà un token di sessione.
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "secret123", "email": "[email protected]"}' \
  https://parseapi.back4app.com/users
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "secret123", "email": "alice@example.com"}' \
  https://parseapi.back4app.com/users
﻿
Utilizza il token di sessione restituito per le richieste successive che richiedono privilegi utente. In Go, invieresti lo stesso tipo di richiesta HTTP da un client http come dimostrato in precedenza.
Accesso sociale
Per gli accessi sociali come Google o Facebook, dovrai configurare le impostazioni OAuth su Back4App. Questi flussi spesso comportano lo scambio di token. Consulta la Documentazione per l'accesso con Apple / Accesso sociale per dettagli.
Passaggio 6 – Gestione dello Storage dei File
Impostazione e Caricamento
Puoi memorizzare file su Back4App inviandoli come dati codificati in base64 o multipart/form-data:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
﻿
Dopo il caricamento, puoi allegare il file a un oggetto memorizzando l'URL del file restituito o il puntatore del file. In Go, crea una richiesta http nello stesso modo: assicurati solo di codificare correttamente il contenuto del file.
Passaggio 7 – Verifica Email e Ripristino Password
Importanza
La verifica dell'email assicura che gli utenti controllino l'email fornita, mentre il ripristino della password li aiuta a recuperare gli account. Entrambe le funzionalità aumentano la sicurezza e la fiducia.
Abilitare la Verifica Email
Vai al tuo Back4App Dashboard.
Sotto Impostazioni Email, abilita le email di verifica.
Personalizza i tuoi modelli email se necessario.
Quando un utente si registra, un'email di verifica viene inviata automaticamente.
Ripristino Password
Usa il endpoint REST requestPasswordReset per avviare un ripristino della password:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cosa Fanno i Cloud Jobs
I Cloud Jobs vengono eseguiti secondo un programma per automatizzare compiti come la pulizia dei dati obsoleti o l'invio di newsletter settimanali.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
﻿
Distribuisci questo lavoro e programmarlo nel tuo Back4App Dashboard > Impostazioni App > Impostazioni Server > Lavori in Background.
﻿
Passo 9 – Integrazione dei Webhook
Perché i Webhook
I Webhook ti permettono di notificare servizi esterni quando si verificano determinati eventi. Ad esempio, potresti inviare avvisi Slack quando vengono creati nuovi elementi Todo.
Vai alla sezione dei Webhook nel tuo Back4App Dashboard.
Configura il tuo endpoint (come https://your-external-service.com/webhook).
Assegna i trigger (ad esempio, afterSave su Todo).
Aggiunta di un Webhook
﻿
Puoi anche attivare API esterne dal Cloud Code scrivendo una richiesta http client se preferisci un controllo diretto degli eventi.
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Panoramica
L'app Admin di Back4App è un'interfaccia point-and-click che puoi condividere con membri del team non tecnici per gestire i dati.
Abilita l'app Admin
Vai a Altro > App Admin nel tuo Dashboard di Back4App.
Abilita e crea un utente admin.
Abilita l'app Admin
﻿
Usa il tuo sottodominio scelto per accedere a un'interfaccia semplice per la manipolazione dei dati. Questo ti libera dalla scrittura di query dirette o codice personalizzato per eseguire operazioni di base.
Conclusione
In questa guida, hai scoperto come costruire un backend per Golang utilizzando Back4App.
Hai esplorato come connetterti al database tramite API RESTful, applicare misure di sicurezza con ACL e CLP, eseguire attività programmate con Cloud Jobs, integrare servizi esterni utilizzando Webhook e impostare l'autenticazione degli utenti e lo storage dei file.
Con il pacchetto http di Go e le robuste funzionalità di Back4App, puoi creare un backend potente che risparmia tempo e scala senza sforzo.
Ora che hai padroneggiato le basi, puoi estendere la logica della tua funzione handler di Golang, connetterti a nuovi endpoint API e costruire un'applicazione ricca che soddisfi le tue esigenze.
Prossimi Passi
Affina la tua app Golang: Aggiungi funzionalità avanzate come accesso basato su ruoli, o ottimizza il tuo server http per la produzione.
Scopri di più sulle query in tempo reale: Integra Live Queries per app collaborative.
Esplora la documentazione avanzata di Back4App: Ottimizza le tue ACL, log e analisi.
Incorpora API di terze parti: Usa Cloud Code o webhook diretti per espandere la funzionalità del tuo backend.
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Deno?
AVANTI IL PROSSIMO
Come costruire un backend per Symfony?