Quickstarters
Come costruire un backend per Symfony?

29min
Introduzione
In questo tutorial, imparerai come costruire un backend per Symfony utilizzando Back4App. 
Ti mostreremo come utilizzare le robuste funzionalità di Back4App—compresa la gestione del database, Cloud Code, REST e GraphQL API—per creare un backend sicuro, scalabile ed efficiente che funzioni senza problemi con la tua applicazione Symfony. 
Scoprirai anche come gestire l'autenticazione degli utenti, l'archiviazione dei file e gli aggiornamenti in tempo reale tramite Live Queries (se applicabile per la tua architettura).
Sfruttando la rapida configurazione e la piattaforma intuitiva di Back4App, risparmierai tempo e sforzi rispetto alla gestione manuale di server e database. 
Acquisirai esperienza pratica in sicurezza avanzata, pianificazione di attività con Cloud Jobs, configurazione di webhook e altre funzionalità essenziali per uno sviluppo backend affidabile.
Dopo aver completato questo tutorial, puoi espandere o personalizzare con sicurezza il tuo backend Symfony per la produzione, integrare API esterne e aggiungere logica aziendale complessa secondo necessità.
Requisiti
Un account Back4app
Registrati gratuitamente qui.
Un nuovo progetto Back4app
Iniziare con Back4app.
Configurazione specifica di Symfony
Assicurati di avere Symfony installato localmente. Conferma di avere PHP e Composer pronti.
Conoscenza di base di Symfony
Familiarità con controller, servizi e templating è utile. Documentazione ufficiale di Symfony.
Node.js (opzionale, per alcuni strumenti di build)
Se prevedi di utilizzare strumenti basati su Node per compiti front-end, installa Node.js.
Assicurati che il tuo ambiente Symfony e il progetto Back4App siano impostati prima di iniziare. Questo ti aiuterà a seguire i passaggi senza problemi.
Passo 1 – Creare un nuovo progetto su Back4App e connettersi
Crea un progetto Back4App:
Accedi al tuo account Back4App.
Clicca su “Nuova App” nel dashboard.
Dagli un nome (ad esempio, “Symfony-Backend-Tutorial”).
﻿
Una volta creato, appare nel tuo dashboard di Back4App. Questo progetto è la tua base backend.
Collegati con REST o GraphQL:
Nelle “Impostazioni App” o “Sicurezza e Chiavi” della tua app, trova il tuo ID Applicazione e Chiave API REST (e l'endpoint GraphQL se prevedi di utilizzare GraphQL).
Annota il tuo URL del Server Parse (ad esempio, https://parseapi.back4app.com).
Poiché Symfony non ha un SDK Parse nativo, dovrai fare affidamento sul client HTTP di Symfony o su una libreria come Guzzle per comunicare con le API REST o GraphQL di Back4App.
﻿
Di seguito è riportato un esempio che utilizza il Symfony HttpClient:
PHP
// src/Service/Back4AppClient.php

namespace App\Service;

use Symfony\Component\HttpClient\HttpClient;

class Back4AppClient
{
    private $appId;
    private $restKey;
    private $baseUrl;

    public function __construct(string $appId, string $restKey, string $baseUrl)
    {
        $this->appId = $appId;
        $this->restKey = $restKey;
        $this->baseUrl = $baseUrl;
    }

    public function createObject(string $className, array $data)
    {
        $client = HttpClient::create();
        $response = $client->request('POST', $this->baseUrl.'/classes/'.$className, [
            'headers' => [
                'X-Parse-Application-Id' => $this->appId,
                'X-Parse-REST-API-Key'   => $this->restKey,
                'Content-Type'          => 'application/json'
            ],
            'json' => $data,
        ]);
        return $response->toArray();
    }
}
// src/Service/Back4AppClient.php

namespace App\Service;

use Symfony\Component\HttpClient\HttpClient;

class Back4AppClient
{
    private $appId;
    private $restKey;
    private $baseUrl;

    public function __construct(string $appId, string $restKey, string $baseUrl)
    {
        $this->appId = $appId;
        $this->restKey = $restKey;
        $this->baseUrl = $baseUrl;
    }

    public function createObject(string $className, array $data)
    {
        $client = HttpClient::create();
        $response = $client->request('POST', $this->baseUrl.'/classes/'.$className, [
            'headers' => [
                'X-Parse-Application-Id' => $this->appId,
                'X-Parse-REST-API-Key'   => $this->restKey,
                'Content-Type'          => 'application/json'
            ],
            'json' => $data,
        ]);
        return $response->toArray();
    }
}
﻿
Questo servizio ti aiuterà a fare richieste al tuo backend di Back4App da dentro Symfony.
Passo 2 – Configurazione del Database
Creazione di un Modello di Dati
Su Back4App, definirai classi (tabelle) che memorizzano i tuoi dati. Diciamo che vuoi una Todo classe per contenere i compiti:
Naviga verso il Database nel tuo dashboard di Back4App.
Crea una nuova classe “Todo” e aggiungi campi come title (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
In alternativa, lascia che il Back4App AI Agent crei il tuo modello di dati:
Apri l'AI Agent nel tuo Dashboard di progetto.
Descrivi il tuo modello di dati (ad es., “Crea una classe Todo con i campi title e isCompleted.”).
Genera automaticamente lo schema.
﻿
Lettura e Scrittura dei Dati usando REST
Per creare un nuovo Todo da un controller Symfony, puoi fare:
PHP
use App\Service\Back4AppClient;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class TodoController extends AbstractController
{
    #[Route('/todo/new', name: 'new_todo')]
    public function new(Back4AppClient $client)
    {
        $data = [
            'title' => 'Buy groceries',
            'isCompleted' => false
        ];
        $result = $client->createObject('Todo', $data);
        
        return $this->json($result);
    }
}
use App\Service\Back4AppClient;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class TodoController extends AbstractController
{
    #[Route('/todo/new', name: 'new_todo')]
    public function new(Back4AppClient $client)
    {
        $data = [
            'title' => 'Buy groceries',
            'isCompleted' => false
        ];
        $result = $client->createObject('Todo', $data);
        
        return $this->json($result);
    }
}
﻿
Per query, usa una richiesta GET con le tue credenziali:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
﻿
Lettura e Scrittura dei Dati usando GraphQL
Puoi anche integrare GraphQL in Symfony utilizzando una libreria client GraphQL. Un esempio di mutazione per creare un Todo è:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the kitchen"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the kitchen"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Lavorare con le Query Live (Opzionale)
Se la tua app Symfony ha bisogno di dati in tempo reale, potresti incorporare Live Queries in un contesto più front-end o microservizio in tempo reale. Configura le Live Queries nelle Impostazioni del Server su Back4App, quindi collega un client WebSocket. Symfony può rispondere a o trasmettere questi aggiornamenti tramite un layer separato in tempo reale se necessario.
Passo 3 – Applicare la Sicurezza con ACL e CLP
ACL (Liste di Controllo degli Accessi)
Le ACL ti permettono di controllare chi può leggere o scrivere un oggetto. Ad esempio, puoi applicare un ACL nel codice quando crei dati con l'API REST aggiungendo i campi _ACL nel tuo JSON. Ad esempio:
JSON
{
  "title": "Private Task",
  "isCompleted": false,
  "_ACL": {
    "UserObjectIdHere": {
      "read": true,
      "write": true
    }
  }
}
{
  "title": "Private Task",
  "isCompleted": false,
  "_ACL": {
    "UserObjectIdHere": {
      "read": true,
      "write": true
    }
  }
}
﻿
CLP (Permessi a Livello di Classe)
I Permessi a Livello di Classe ti permettono di impostare regole di accesso ampie per un'intera classe:
Apri il Database nel dashboard di Back4App.
Seleziona la tua classe (ad esempio, “Todo”).
Vai alla scheda Permessi e configura l'accesso in lettura/scrittura.
﻿
Per ulteriori informazioni, visita le Linee guida sulla sicurezza delle app.
Passo 4 – Scrivere Funzioni di Cloud Code
Il Cloud Code ti consente di eseguire JavaScript sicuro lato server senza gestire l'infrastruttura. Mentre Symfony è in PHP, puoi comunque delegare determinate attività a Cloud Code su Back4App per logica avanzata, trigger e validazioni.
Esempio: Convalidare un Todo Prima del Salvataggio
JS
// main.js

Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Distribuzione
Usa il Back4App CLI o il dashboard per distribuire main.js.
Invoca le tue Funzioni Cloud tramite REST o GraphQL dai tuoi servizi Symfony.
﻿
Passo 5 – Configurare l'Autenticazione
La gestione degli utenti in Back4App si basa sulla classe Parse User . Con Symfony, puoi gestire le registrazioni degli utenti, i login e il ripristino delle password tramite chiamate REST o GraphQL.
Registrati / Accedi tramite REST
Bash
# Sign Up
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": "alex", "password": "symfony123", "email": "[email protected]"}' \
  https://parseapi.back4app.com/users

# Log In
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  --data-urlencode 'username=alex' \
  --data-urlencode 'password=symfony123' \
  https://parseapi.back4app.com/login
# Sign Up
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": "alex", "password": "symfony123", "email": "alex@example.com"}' \
  https://parseapi.back4app.com/users

# Log In
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  --data-urlencode 'username=alex' \
  --data-urlencode 'password=symfony123' \
  https://parseapi.back4app.com/login
﻿
Utilizza un servizio Symfony per incapsulare queste chiamate se hai bisogno di flussi utente programmati.
Accesso Sociale
Se prevedi di integrare l'accesso con Google o Apple, fai riferimento a Documentazione sull'accesso sociale di Back4App. Configurerai le tue app OAuth e farai chiamate REST specifiche per completare l'autenticazione.
Passo 6 – Gestione dello Storage dei File
Caricamento File con REST
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: image/png" \
  --data-binary '@localImage.png' \
  https://parseapi.back4app.com/files/localImage.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: image/png" \
  --data-binary '@localImage.png' \
  https://parseapi.back4app.com/files/localImage.png
﻿
Dopo il caricamento, riceverai un URL del file. Puoi memorizzare quel link in qualsiasi classe (ad esempio, Todo) come riferimento a quel file.
Passo 7 – Verifica Email e Reimpostazione Password
Configurazione Email
Vai alle impostazioni email in Back4App.
Abilita la verifica dell'email e i modelli di reset della password.
Personalizza le righe “Da” e “Oggetto” come necessario.
Questo assicura che tutte le registrazioni richiedano conferme email valide.
Passo 8 – Pianificazione dei compiti con Cloud Jobs
Esempio di Cloud Job
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async () => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  query.lessThan('createdAt', new Date(now - THIRTY_DAYS));

  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async () => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  query.lessThan('createdAt', new Date(now - THIRTY_DAYS));

  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Pianifica questo cleanupOldTodos lavoro nel tuo dashboard di Back4App per eseguirlo quotidianamente, migliorando la gestione dei dati.
Passo 9 – Integrazione dei Webhook
I Webhook consentono a Back4App di inviare richieste HTTP a servizi esterni. Ad esempio, puoi inviare un ping a un endpoint Slack ogni volta che viene creato un nuovo Todo :
Vai su Altro > WebHooks nel tuo dashboard di Back4App.
Aggiungi un Webhook specificando il tuo endpoint esterno.
Attiva l'evento alla creazione dell'oggetto nella classe Todo.
Aggiunta di un Webhook
﻿
Passo 10 – Esplorare il pannello di amministrazione di Back4App
Usa il Back4App Admin App per un'interfaccia di gestione dei dati facile da usare:
Abilita l'Admin App da App Dashboard > Altro > Admin App.
Crea un utente Admin con un nome utente e una password sicuri.
Assegna un sottodominio personalizzato per un accesso facile.
Abilita l'Admin App
﻿
Questa funzione aiuta i membri del team non tecnici a visualizzare e gestire i record senza dover entrare nel codice.
Conclusione
Hai imparato come costruire un backend per Symfony utilizzando Back4App. Questo includeva:
Creare un nuovo progetto su Back4App come base.
Configurare il database con classi, campi e relazioni.
Proteggere i dati con ACL e CLP.
Sfruttare il Cloud Code per la logica lato server.
Gestire l'autenticazione degli utenti (registrazione, accesso, reset della password).
Gestire lo storage dei file con l'API REST.
Impostare i Cloud Jobs per compiti periodici.
Integrare i webhook per connettere servizi esterni.
Navigare nel Pannello di Amministrazione di Back4App per una gestione dei dati semplice.
Questi passaggi ti offrono una solida struttura per costruire e scalare la tua applicazione Symfony. Espandi questa architettura per gestire logiche più complesse, integrare gateway di pagamento o aggiungere funzionalità di sicurezza avanzate. Con Back4App, risparmi tempo e sforzi su hosting e infrastruttura—così puoi concentrarti sulla fornitura della migliore esperienza utente possibile.
Prossimi Passi
Costruire un'app Symfony pronta per la produzione personalizzando il tuo backend di Back4App per un traffico più elevato e esigenze di prestazioni avanzate.
Integrare funzionalità avanzate come accesso basato su ruoli, analisi o API di terze parti per i pagamenti.
Esplora la documentazione ufficiale di Back4App per approfondimenti su sicurezza, registri e monitoraggio.
Controlla altri tutorial per combinare questo backend con servizi in tempo reale o per creare siti web dinamici con aggiornamenti live.
Seguendo queste strategie, il tuo progetto Symfony guadagna un backend potente ed efficiente. Abbraccia Back4App per semplificare la manutenzione e far evolvere rapidamente le capacità della tua applicazione. Buona fortuna nella costruzione del tuo prossimo capolavoro Symfony!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Golang?
AVANTI IL PROSSIMO
Come costruire un backend per Ionic?