Esecuzione di Django nell'ambiente standard di App Engine

Le app Django in esecuzione nell'standard App Engine scalano in modo dinamico in base al traffico.

Questo tutorial presuppone che tu abbia familiarità con lo sviluppo web di Django. Se non hai mai sviluppato Django, è buona norma lavorare attraverso la scrittura della tua prima app di Django prima di continuare.

Questo tutorial illustra in modo specifico Django, ma puoi utilizzare questo processo di deployment con altri framework basati su Django, come Wagtail e Django CMS.

Questo tutorial utilizza Django 4, che richiede almeno Python 3.8. Lo standard App Engine supporta Python 3.7 e versioni successive, incluso Python 3.8.

Obiettivi

In questo tutorial, imparerai a:

Crea e connetti un database Cloud SQL.
Creare e utilizzare i valori dei secret di Secret Manager.
Eseguire il deployment di un'app Django nello standard App Engine.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Cloud SQL Admin API, Secret Manager, and Cloud Build.

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Cloud SQL Admin API, Secret Manager, and Cloud Build.

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Se non lo hai già fatto, inizializza App Engine e seleziona la regione che preferisci:
```
gcloud app create
```

prepara l'ambiente

Clona un'app di esempio

Il codice per l'app Django di esempio si trova nel repository GoogleCloudPlatform/python-docs-samples su GitHub.

Puoi scaricare l'esempio come file ZIP ed estrarlo oppure clonarlo sulla tua macchina locale:
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```

Vai alla directory che contiene il codice di esempio:

Linux/macOS

cd python-docs-samples/appengine/standard_python3/django

Windows

cd python-docs-samples\appengine\standard_python3\django

Conferma la configurazione di Python

Questo tutorial si basa su Python per eseguire l'applicazione di esempio sulla tua macchina. Il codice campione richiede anche l'installazione di dipendenze

Per ulteriori dettagli, consulta la guida per l'ambiente di sviluppo di Python.

Verifica che Python sia almeno la versione 3.8.
```
 python -V
```
Dovresti vedere Python 3.8.0 o un numero superiore.

Nota: se visualizzi un numero di versione che inizia con "2", potrebbe essere necessario eseguire python3 anziché python. In tal caso, ricordati di fare riferimento all'installazione Python scelta quando esegui i comandi python.

Crea un ambiente virtuale Python e installa le dipendenze:

Linux/macOS

python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Windows

python -m venv venv
venv\scripts\activate
pip install --upgrade pip
pip install -r requirements.txt

Scarica il proxy di autenticazione Cloud SQL per connetterti a Cloud SQL dalla tua macchina locale

Una volta eseguito il deployment, l'app utilizza il proxy di autenticazione Cloud SQL integrato nell'ambiente standard di App Engine per comunicare con l'istanza Cloud SQL. Tuttavia, per testare l'app in locale, devi installare e utilizzare una copia locale del proxy nel tuo ambiente di sviluppo. Per maggiori dettagli, consulta la guida al proxy di autenticazione Cloud SQL.

Il proxy di autenticazione Cloud SQL utilizza l'API Cloud SQL per interagire con l'istanza SQL. Per farlo, richiede l'autenticazione dell'applicazione tramite gcloud CLI.

Autentica e acquisisci le credenziali per l'API:
```
gcloud auth application-default login
```
Scarica e installa il proxy di autenticazione Cloud SQL sulla tua macchina locale.
Linux a 64 bit
1. Scarica il proxy di autenticazione Cloud SQL:
```
curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.linux.amd64
```
2. Rendi eseguibile il proxy di autenticazione Cloud SQL:
```
chmod +x cloud-sql-proxy
```
Linux a 32 bit
1. Scarica il proxy di autenticazione Cloud SQL:
```
curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.linux.386
```
2. Se il comando curl non viene trovato, esegui sudo apt install curl e ripeti il comando di download.
3. Rendi eseguibile il proxy di autenticazione Cloud SQL:
```
chmod +x cloud-sql-proxy
```
macOS a 64 bit
1. Scarica il proxy di autenticazione Cloud SQL:
```
curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.darwin.amd64
```
2. Rendi eseguibile il proxy di autenticazione Cloud SQL:
```
chmod +x cloud-sql-proxy
```
Mac M1
1. Scarica il proxy di autenticazione Cloud SQL:
```
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.darwin.arm64
  
```
2. Rendi eseguibile il proxy di autenticazione Cloud SQL:
```
  chmod +x cloud-sql-proxy
  
```
Windows a 64 bit
Fai clic con il pulsante destro del mouse su https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.x64.exe e seleziona Salva link con nome per scaricare il proxy di autenticazione Cloud SQL. Rinomina il file come cloud-sql-proxy.exe.

Windows a 32 bit
Fai clic con il pulsante destro del mouse su https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.10.1/cloud-sql-proxy.x86.exe e seleziona Salva link con nome per scaricare il proxy di autenticazione Cloud SQL. Rinomina il file come cloud-sql-proxy.exe.
Immagine Docker del proxy di autenticazione Cloud SQL

Il proxy di autenticazione Cloud SQL ha immagini container diverse, ad esempio distroless, alpine e buster. L'immagine container predefinita del proxy di autenticazione Cloud SQL utilizza distroless, che non contiene shell. Se hai bisogno di una shell o di strumenti correlati, scarica un'immagine basata su alpine o buster. Per maggiori informazioni, consulta Immagini container di autenticazione proxy di Cloud SQL.

Puoi eseguire il pull dell'immagine più recente sulla tua macchina locale utilizzando Docker utilizzando il seguente comando:
```
docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.10.1
```
Nota: il proxy di autenticazione Cloud SQL utilizza un repository che supporta il dominio gcr.io, ma gestisce le immagini da Artifact Registry. Per maggiori informazioni, consulta Transizione da Container Registry.
Altro sistema operativo
Per gli altri sistemi operativi non inclusi qui, puoi compilare il proxy di autenticazione Cloud SQL dall'origine.
Puoi scegliere di spostare il download in una posizione comune, ad esempio una posizione sul tuo PATH o nella tua home directory. Se scegli di farlo, quando avvii il proxy di autenticazione Cloud SQL più avanti nel tutorial, ricordati di fare riferimento alla posizione scelta quando utilizzi i comandi cloud_sql_proxy.

Crea servizi di supporto

Questo tutorial utilizza diversi servizi Google Cloud per fornire il database, l'archiviazione multimediale e l'archiviazione dei secret a supporto del progetto Django di cui è stato eseguito il deployment. Il deployment di questi servizi è stato eseguito in una regione specifica. Per garantire l'efficienza tra i servizi, il deployment di tutti i servizi deve essere eseguito nella stessa regione. Per scoprire di più sulla regione più vicina a te, consulta la pagina Prodotti disponibili per regione.

Questo tutorial utilizza i meccanismi integrati di hosting di asset statici nello standard App Engine.

Configura un'istanza Cloud SQL per PostgreSQL

Django supporta ufficialmente più database relazionali, ma offre il supporto maggiore per PostgreSQL. Poiché il database PostgreSQL è supportato da Cloud SQL, questo tutorial sceglie di usare quel tipo di database.

La sezione seguente descrive la creazione di un'istanza, un database e un utente di database PostgreSQL per l'app.

Crea l'istanza PostgreSQL:
Console
1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.
  
  Vai alla pagina Istanze Cloud SQL
2. Fai clic su Crea istanza.
3. Fai clic su PostgreSQL.
4. Nel campo ID istanza, inserisci INSTANCE_NAME.
5. Inserisci una password per l'utente Postgres.
6. Mantieni i valori predefiniti per gli altri campi.
7. Fai clic su Crea.
Sono necessari alcuni minuti per creare l'istanza e renderla pronta all'uso.
gcloud
- Crea l'istanza PostgreSQL:
```
gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_13 \
    --tier db-f1-micro \
    --region REGION
```
Sostituisci quanto segue:
- INSTANCE_NAME: nome dell'istanza Cloud SQL
- PROJECT_ID: l'ID del progetto Google Cloud
- REGION: la regione Google Cloud
Sono necessari alcuni minuti per creare l'istanza e renderla pronta all'uso.
All'interno dell'istanza creata, crea un database:
Console
1. Nella pagina dell'istanza, vai alla scheda Database.
2. Fai clic su Crea database.
3. Nella finestra di dialogo Nome database, inserisci DATABASE_NAME.
4. Fai clic su Crea.
gcloud
- Crea il database all'interno dell'istanza creata di recente:
```
gcloud sql databases create DATABASE_NAME \
    --instance INSTANCE_NAME
```
  Sostituisci DATABASE_NAME con un nome per il database all'interno dell'istanza.
Crea un utente del database:

Nota: gli utenti creati in questo modo ricevono diritti di database aggiuntivi. Per un metodo alternativo, consulta Limitare i privilegi utente del database.
Console
1. Nella pagina dell'istanza, vai alla scheda Utenti.
2. Fai clic su Aggiungi account utente.
3. Nella finestra di dialogo Aggiungi un account utente all'istanza in "Autenticazione integrata":
4. Inserisci il nome utente DATABASE_USERNAME.
5. Inserisci la password DATABASE_PASSWORD
6. Fai clic su Aggiungi.
gcloud
- Crea l'utente nell'istanza creata di recente:
```
gcloud sql users create DATABASE_USERNAME \
    --instance INSTANCE_NAME \
    --password DATABASE_PASSWORD
```
  Sostituisci PASSWORD con una password sicura.

Archivia i valori dei secret in Secret Manager

Ora che i servizi di supporto sono configurati, Django ha bisogno di informazioni su questi servizi. Anziché inserire questi valori direttamente nel codice sorgente di Django, questo tutorial utilizza Secret Manager per archiviare queste informazioni in modo sicuro.

L'standard App Engine interagisce con i secret utilizzando il proprio account di servizio.

Crea un file di ambiente Django come secret di Secret Manager

Le impostazioni necessarie per avviare Django vengono archiviate in un file env protetto. L'app di esempio utilizza l'API Secret Manager per recuperare il valore del secret e il pacchetto django-environ per caricare i valori nell'ambiente Django. Il secret è configurato per l'accesso allo standard App Engine.

Crea un file denominato .env che definisce la stringa di connessione al database, il nome del bucket multimediale e un nuovo valore SECRET_KEY:

echo DATABASE_URL=postgres://DATABASE_USERNAME:DATABASE_PASSWORD@//cloudsql/PROJECT_ID:REGION:INSTANCE_NAME/DATABASE_NAME > .env
echo GS_BUCKET_NAME=PROJECT_ID_MEDIA_BUCKET >> .env
echo SECRET_KEY=$(cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 50 | head -n1) >> .env

Archivia il secret in Secret Manager:
Console
1. Nella console Google Cloud, vai alla pagina di Secret Manager.
  
  Vai alla pagina di Secret Manager
2. Fai clic su Crea secret
3. Nel campo Nome, inserisci django_settings.
4. Nella finestra di dialogo Valore secret, incolla i contenuti del file .env.
5. Fai clic su Crea secret.
6. Elimina il file locale per evitare l'override delle impostazioni locali.
gcloud
1. Crea un nuovo secret, django_settings, con il valore del file .env:
```
gcloud secrets create django_settings --data-file .env
```
2. Per confermare la creazione del secret, controllalo:
```
gcloud secrets describe django_settings

gcloud secrets versions access latest --secret django_settings
```
3. Elimina il file locale per evitare le sostituzioni delle impostazioni locali:
```
rm .env
```
Configura l'accesso al secret:
Console
1. Fai clic sulla scheda Autorizzazioni.
2. Fai clic su Aggiungi.
3. Nel campo Nuovi membri, inserisci PROJECT_ID@appspot.gserviceaccount.com, quindi premi Enter.
4. Nel menu a discesa Ruolo, seleziona Funzione di accesso ai secret di Secret Manager.
5. Fai clic su Salva.
gcloud
1. Concedi l'accesso al secret all'account di servizio standard di App Engine:
```
gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:PROJECT_ID@appspot.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor
```

Esecuzione dell'applicazione nel computer locale

Con i servizi di supporto configurati, ora puoi eseguire l'app sul tuo computer. Questa configurazione consente lo sviluppo locale, la creazione di un super user e l'applicazione delle migrazioni dei database.

In un terminale separato, avvia il proxy di autenticazione Cloud SQL:
Linux/macOS
```
./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME
```
Windows
```
cloud-sql-proxy.exe PROJECT_ID:REGION:INSTANCE_NAME
```
Questo passaggio stabilisce una connessione dal computer locale all'istanza Cloud SQL a scopo di test locale. Mantieni il proxy di autenticazione Cloud SQL in esecuzione per tutta la durata di test dell'app localmente. L'esecuzione di questo processo in un terminale separato ti consente di continuare a lavorare durante l'esecuzione del processo.
Nel terminale originale, imposta l'ID progetto localmente (utilizzato dall'API Secret Manager):
Linux/macOS
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Windows
```
set GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Imposta una variabile di ambiente per indicare che stai utilizzando il proxy di autenticazione Cloud SQL (questo valore è riconosciuto nel codice):
Linux/macOS
```
export USE_CLOUD_SQL_AUTH_PROXY=true
```
Windows
```
set USE_CLOUD_SQL_AUTH_PROXY=true
```

Esegui le migrazioni di Django per configurare i tuoi modelli e asset:

python manage.py makemigrations
python manage.py makemigrations polls
python manage.py migrate
python manage.py collectstatic

Avvia il server web di Django:
```
python manage.py runserver 8080
```
Nel browser, vai all'indirizzo http://localhost:8080.

Se sei in Cloud Shell, fai clic sul pulsante Anteprima web e seleziona Anteprima sulla porta 8080.

Nella pagina viene visualizzato il seguente testo: "Hello, world. Sei nell'indice dei sondaggi". Il server web Django in esecuzione sul computer fornisce le pagine di esempio dell'app.
Premi Ctrl/Cmd+C per arrestare il server web locale.

Utilizzare la Console di amministrazione di Django

Per accedere alla console di amministrazione di Django, devi creare un super user. Poiché disponi di una connessione al database accessibile localmente, puoi eseguire i comandi di gestione:

Crea un super user. Ti verrà chiesto di inserire un nome utente, un indirizzo email e una password.
```
python manage.py createsuperuser
```
Avvia un server web locale:
```
python manage.py runserver
```
Nel browser, vai a http://localhost:8000/admin.
Accedi al sito di amministrazione con il nome utente e la password che hai utilizzato quando hai eseguito createsuperuser.

Eseguire il deployment dell'app nell'ambiente standard di App Engine

Dopo aver configurato tutti i servizi di supporto e aver testato l'applicazione localmente, puoi eseguire il deployment dell'app nello standard di App Engine:

Carica l'app eseguendo questo comando, che esegue il deployment dell'app come descritto in app.yaml e imposta la versione appena sottoposta a deployment come versione predefinita, in modo che gestisca tutto il nuovo traffico:
```
gcloud app deploy
```
Conferma le impostazioni digitando "yes" quando richiesto.
Attendi il messaggio che ti informa del completamento dell'aggiornamento.
Apri app.yaml e aggiorna il valore di APPENGINE_URL con l'URL di cui hai eseguito il deployment:
```
...
env_variables:
    APPENGINE_URL: https://PROJECT_ID.uc.r.appspot.com
```
Carica le modifiche alla configurazione:
```
gcloud app deploy
```

Esecuzione dell'app di cui è stato eseguito il deployment

Il deployment dell'app è stato eseguito. Ora è possibile accedervi:

Apri il sito web di cui è stato eseguito il deployment:
```
gcloud app browse
```

In alternativa, visualizza l'URL e aprilo manualmente:

gcloud app describe --format "value(defaultHostname)"

La richiesta è gestita da un server web in esecuzione nell'ambiente standard di App Engine.

Aggiornamento dell'applicazione

Per aggiornare l'applicazione, apporta modifiche al codice, quindi esegui di nuovo il comando gcloud app deploy.

Il deployment crea una nuova versione dell'app e la imposta alla versione predefinita. Vengono mantenute le versioni precedenti dell'app. Tutte queste versioni dell'app sono risorse fatturabili. Per ridurre i costi, elimina le versioni non predefinite dell'app.

Configurazione per la produzione

Ora hai un deployment di Django funzionante, ma puoi eseguire ulteriori passaggi per assicurarti che la tua applicazione sia pronta per la produzione.

Disattiva debug

Verifica che la variabile DEBUG in mysite/settings.py sia impostata su False. Ciò impedirà all'utente di mostrare pagine di errore dettagliate che potrebbero far scoprire informazioni sulle configurazioni.

Limitare i privilegi utente del database

Tutti gli utenti creati utilizzando Cloud SQL hanno i privilegi associati al ruolo cloudsqlsuperuser: CREATEROLE, CREATEDB e LOGIN.

Per impedire all'utente del database Django di avere queste autorizzazioni, crea manualmente l'utente in PostgreSQL. Devi aver installato il terminale interattivo psql oppure utilizzare Cloud Shell in cui questo strumento è preinstallato.

Console

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell
In Cloud Shell, usa il terminale integrato per connetterti alla tua istanza INSTANCE_NAME:
```
gcloud sql connect INSTANCE_NAME --user postgres
```
Inserisci la password utente Postgres.

Stai utilizzando psql. Dovresti vedere la richiesta postgres=>.
Creare un utente:
```
CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
Sostituisci PASSWORD con una password casuale e univoca.

Concedi i diritti completi sul nuovo database al nuovo utente:

GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

Uscita psql:
```
\q
```

gcloud

Avvia una connessione all'istanza SQL:
```
gcloud sql connect INSTANCE_NAME --user postgres
```
Sostituisci INSTANCE_NAME con l'istanza Cloud SQL creata.
Inserisci la password utente Postgres.

Stai utilizzando psql. Dovresti vedere la richiesta postgres=>.

Creare un utente:

CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

Concedi i diritti completi sul nuovo database al nuovo utente:

GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

Uscita psql:
```
\q
```

comprendi il codice

Applicazione di esempio

L'app di esempio di Django è stata creata utilizzando gli strumenti standard di Django. I comandi seguenti creano il progetto e l'app polls:

django-admin startproject mysite
python manage.py startapp polls

Le visualizzazioni di base, i modelli e le configurazioni delle route sono stati copiati da Scrittura della tua prima app Django (Parte 1 e Parte 2).

Secret di Secret Manager

Il file settings.py contiene il codice che utilizza l'API Python di Secret Manager per recuperare la versione più recente del secret denominato ed eseguirne il pull nell'ambiente (utilizzando django-environ):

env = environ.Env(DEBUG=(bool, False))
env_file = os.path.join(BASE_DIR, ".env")

if os.path.isfile(env_file):
    # Use a local secret file, if provided

    env.read_env(env_file)
# ...
elif os.environ.get("GOOGLE_CLOUD_PROJECT", None):
    # Pull secrets from Secret Manager
    project_id = os.environ.get("GOOGLE_CLOUD_PROJECT")

    client = secretmanager.SecretManagerServiceClient()
    settings_name = os.environ.get("SETTINGS_NAME", "django_settings")
    name = f"projects/{project_id}/secrets/{settings_name}/versions/latest"
    payload = client.access_secret_version(name=name).payload.data.decode("UTF-8")

    env.read_env(io.StringIO(payload))
else:
    raise Exception("No local .env or GOOGLE_CLOUD_PROJECT detected. No secrets found.")

Il secret viene utilizzato per archiviare più valori del secret in modo da ridurre il numero di secret diversi da configurare.

Configurazioni CSRF

Django è dotato di una protezione integrata contro la falsificazione di richieste di cross-site (CSRF). A partire da Django 4.0, le modifiche al funzionamento indicano che è importante comunicare a Django l'URL ospitato, in modo che possa offrire le migliori protezioni per gli utenti che inviano dati.

Devi fornire l'URL dell'app come variabile di ambiente nel file settings.py. Questo è il valore che Django utilizza per le impostazioni pertinenti.

# SECURITY WARNING: It's recommended that you use this when
# running in production. The URL will be known once you first deploy
# to App Engine. This code takes the URL and converts it to both these settings formats.
APPENGINE_URL = env("APPENGINE_URL", default=None)
if APPENGINE_URL:
    # Ensure a scheme is present in the URL before it's processed.
    if not urlparse(APPENGINE_URL).scheme:
        APPENGINE_URL = f"https://{APPENGINE_URL}"

    ALLOWED_HOSTS = [urlparse(APPENGINE_URL).netloc]
    CSRF_TRUSTED_ORIGINS = [APPENGINE_URL]
    SECURE_SSL_REDIRECT = True
else:
    ALLOWED_HOSTS = ["*"]

Override dei secret locali

Se nel file system locale viene trovato un file .env, viene utilizzato al posto del valore di Secret Manager. La creazione di un file .env in locale può essere utile per i test locali (ad esempio, lo sviluppo locale su un database SQLite o altre impostazioni locali).

Connessione al database

Il file settings.py contiene la configurazione del tuo database SQL. Utilizza l'helper env.db() da django-environ per caricare la stringa di connessione impostata in DATABASE_URL nell'impostazione DATABASES.

Quando l'applicazione viene eseguita in locale e si utilizza il proxy di autenticazione Cloud SQL per accedere al database ospitato, il flag USE_CLOUD_SQL_AUTH_PROXY regola le impostazioni del database in modo che utilizzi il proxy.

# Use django-environ to parse the connection string
DATABASES = {"default": env.db()}

# If the flag as been set, configure to use proxy
if os.getenv("USE_CLOUD_SQL_AUTH_PROXY", None):
    DATABASES["default"]["HOST"] = "127.0.0.1"
    DATABASES["default"]["PORT"] = 5432

Contenuti statici ospitati

Il file app.yaml contiene le informazioni di configurazione per il deployment in App Engine. Questo file app.yaml specifica che App Engine pubblica i file statici dalla directory static/:

runtime: python39

env_variables:
  # This setting is used in settings.py to configure your ALLOWED_HOSTS
  # APPENGINE_URL: PROJECT_ID.uc.r.appspot.com

handlers:
# This configures Google App Engine to serve the files in the app's static
# directory.
- url: /static
  static_dir: static/

# This handler routes all requests not caught above to your main app. It is
# required when static routes are defined, but can be omitted (along with
# the entire handlers section) when there are no static files defined.
- url: /.*
  script: auto

Quando l'app viene eseguita in locale con DEBUG abilitato, questi file vengono pubblicati localmente da Django:

from django.conf import settings
from django.conf.urls.static import static
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path("", include("polls.urls")),
    path("admin/", admin.site.urls),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Scopri come configurare PostgreSQL per la produzione
Scopri di più su Django su Google Cloud

Esecuzione di Django nell'ambiente standard di App Engine

Obiettivi

Costi

Prima di iniziare

prepara l'ambiente

Clona un'app di esempio

Linux/macOS

Windows

Conferma la configurazione di Python

Linux/macOS

Windows

Scarica il proxy di autenticazione Cloud SQL per connetterti a Cloud SQL dalla tua macchina locale

Linux a 64 bit

Linux a 32 bit

macOS a 64 bit

Mac M1

Windows a 64 bit

Windows a 32 bit

Immagine Docker del proxy di autenticazione Cloud SQL

Altro sistema operativo

Crea servizi di supporto

Configura un'istanza Cloud SQL per PostgreSQL

Console

gcloud

Console

gcloud

Console

gcloud

Archivia i valori dei secret in Secret Manager

Crea un file di ambiente Django come secret di Secret Manager

Console

gcloud

Console

gcloud

Esecuzione dell'applicazione nel computer locale

Linux/macOS

Windows

Linux/macOS

Windows

Linux/macOS

Windows

Utilizzare la Console di amministrazione di Django

Eseguire il deployment dell'app nell'ambiente standard di App Engine

Esecuzione dell'app di cui è stato eseguito il deployment

Aggiornamento dell'applicazione

Configurazione per la produzione

Disattiva debug

Limitare i privilegi utente del database

Console

gcloud

comprendi il codice

Applicazione di esempio

Secret di Secret Manager

Configurazioni CSRF

Override dei secret locali

Connessione al database

Contenuti statici ospitati

Esegui la pulizia

Elimina il progetto

Passaggi successivi