Esecuzione di Django su Google Kubernetes Engine

Le app Django in esecuzione su GKE scalano in modo dinamico in base al traffico.

Questo tutorial presuppone che tu conosca lo sviluppo web di Django. Se non hai mai utilizzato lo sviluppo Django, ti consigliamo di scrivere la tua prima app 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.

Devi anche avere installato Docker.

Obiettivi

In questo tutorial, imparerai a:

Crea e connetti un database Cloud SQL.
Creare e utilizzare i valori segreti di Kubernetes.
Esegui il deployment di un'app Django in Google Kubernetes Engine.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

prepara l'ambiente

Clonare 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 clonare il repository 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/kubernetes_engine/django_tutorial

Windows

cd python-docs-samples\kubernetes_engine\django_tutorial

Conferma la configurazione 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 all'ambiente di sviluppo di Python.

Verifica che il tuo Python sia almeno la versione 3.7.
```
 python -V
```
Dovresti vedere Python 3.7.3 o un valore superiore.

Nota: se viene visualizzato un numero di versione che inizia con "2", potrebbe essere necessario eseguire python3 anziché python. In questo 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 env
venv\scripts\activate
pip install --upgrade pip
pip install -r requirements.txt

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

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

Il proxy Cloud SQL Auth utilizza l'API Cloud SQL per interagire con la tua istanza SQL. A questo scopo, è necessaria l'autenticazione dell'applicazione tramite gcloud.

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

Windows a 32 bit
Fai clic con il pulsante destro del mouse su https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe e seleziona Salva link con nome per scaricare il proxy Cloud SQL Auth. Rinomina il file come cloud_sql_proxy.exe.
Immagine Docker proxy Cloud SQL Auth
Per convenienza, diverse immagini container che contengono il proxy di autenticazione Cloud SQL sono disponibili su GitHub nel repository proxy di Cloud SQL Auth. Puoi estrarre l'immagine più recente sulla tua macchina locale utilizzando Docker con il seguente comando:
```
docker pull gcr.io/cloudsql-docker/gce-proxy:1.30.1
```
Altro sistema operativo
Per altri sistemi operativi non inclusi, puoi compilare il proxy di autenticazione Cloud SQL dall'origine.
Puoi scegliere di spostare il download in un punto comune, ad esempio una posizione in PATH o nella tua directory home. Se scegli di farlo, quando avvii il proxy di autenticazione Cloud SQL più avanti nel tutorial, ricorda di fare riferimento alla località 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 segreta che supportano il progetto Django di cui è stato eseguito il deployment. Il deployment di questi servizi si svolge in un'area geografica specifica. Per ottimizzare l'efficienza tra i servizi, devi eseguire il deployment di tutti i servizi nella stessa area geografica. Per ulteriori informazioni sull'area geografica più vicina a te, consulta Prodotti disponibili per area geografica.

Configurare un'istanza Cloud SQL per PostgreSQL

Django supporta ufficialmente più database relazionali, ma offre il maggiore supporto per PostgreSQL. PostgreSQL è supportato da Cloud SQL, quindi questo tutorial sceglie di utilizzare questo 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. In Cloud Console, 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 prima che sia pronta per l'utilizzo.
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 progetto di Google Cloud
- REGION: l'area geografica Google Cloud
Sono necessari alcuni minuti per creare l'istanza e prima che sia pronta per l'utilizzo.
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. Vedi Limitare i privilegi utente del database per un metodo alternativo.
Console
1. Nella pagina dell'istanza, vai alla scheda Utenti.
2. Fai clic su Add User Account (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 all'interno dell'istanza creata di recente:
```
gcloud sql users create DATABASE_USERNAME \
    --instance INSTANCE_NAME \
    --password DATABASE_PASSWORD
```
  Sostituisci PASSWORD con una password sicura.

Crea un account di servizio

Il proxy richiede un account di servizio con privilegi di editor per l'istanza Cloud SQL. Per ulteriori informazioni sugli account di servizio, consulta la panoramica sull'autenticazione di Google Cloud.

Se stai eseguendo la connessione da Compute Engine, assicurati che la VM disponga del scope corretto per connettersi utilizzando l'API Cloud SQL Admin.

Configura l'account di servizio in modo che abbia uno dei seguenti ambiti di accesso:

https://www.googleapis.com/auth/sqlservice.admin
https://www.googleapis.com/auth/cloud-platform

In Cloud Console, vai alla pagina Account di servizio.
Vai agli account di servizio
Seleziona il progetto che contiene l'istanza Cloud SQL.
Fai clic su Crea account di servizio.
Nel campo Nome account di servizio, inserisci un nome descrittivo per l'account di servizio.
Modifica l'ID account di servizio in un valore univoco e riconoscibile, quindi fai clic su Crea e continua.
Fai clic sul campo Seleziona un ruolo e scegli uno dei seguenti ruoli:
- Client Cloud SQL > client Cloud SQL
- Cloud SQL > Editor Cloud SQL
- Amministratore Cloud SQL > Cloud SQL
Fai clic su Fine per completare la creazione dell'account di servizio.
Fai clic sul menu azione per il nuovo account di servizio, quindi seleziona Gestisci chiavi.
Fai clic sul menu a discesa Aggiungi chiave, quindi fai clic su Crea nuova chiave.
Verifica che il tipo di chiave sia JSON e fai clic su Create (Crea).
Il file della chiave privata viene scaricato sulla macchina. Puoi spostarlo in un'altra posizione. Tieni il file della chiave al sicuro.

Configura le impostazioni del database

Utilizza i comandi seguenti per impostare le variabili di ambiente per l'accesso al database. Queste variabili di ambiente vengono utilizzate per i test locali.

Linux/MacOS

export DATABASE_NAME=DATABASE_NAME
export DATABASE_USER=DATABASE_USERNAME
export DATABASE_PASSWORD=DATABASE_PASSWORD

Windows

set DATABASE_USER=DATABASE_USERNAME
set DATABASE_PASSWORD=DATABASE_PASSWORD

Impostare la configurazione di GKE

Questa applicazione è rappresentata in una singola configurazione Kubernetes denominata polls. In polls.yaml, sostituisci <your-project-id> con l'ID progetto Google Cloud (PROJECT_ID).

Esegui questo comando e prendi nota del valore di connectionName:

gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"

Nel file polls.yaml, sostituisci <your-cloudsql-connection-string> con il valore connectionName.

Esecuzione dell'applicazione nel computer locale

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

In un terminale separato, avvia il proxy di autenticazione Cloud SQL:
Linux/macOS
```
./cloud_sql_proxy -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
```
Windows
```
cloud_sql_proxy.exe -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
```
Questo passaggio stabilisce una connessione dal computer locale alla tua istanza Cloud SQL a scopo di test locale. Mantieni il proxy Cloud SQL Auth in esecuzione per tutto il tempo per testare l'app localmente. L'esecuzione di questo processo in un terminale separato ti consente di continuare a lavorare durante l'esecuzione del processo.

In un nuovo terminale, imposta l'ID progetto localmente:

Linux/macOS

  export GOOGLE_CLOUD_PROJECT=PROJECT_ID

Windows

  set GOOGLE_CLOUD_PROJECT=PROJECT_ID

Esegui le migrazioni Django per configurare i modelli e gli 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
```
Nel browser, vai alla pagina http://localhost:8000.

Nella pagina viene visualizzato il seguente testo: "Hello world. Sei nell'indice dei sondaggi." Il server web di 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 Django

Per accedere alla Console di amministrazione di Django devi creare un super user. Poiché hai una connessione accessibile in locale al database, puoi eseguire comandi di gestione:

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

Eseguire il deployment dell'app in GKE

Quando il deployment dell'app è in Google Cloud, utilizza il server Gunicorn. Gunicorn non pubblica contenuti statici, pertanto l'app utilizza Cloud Storage per pubblicare contenuti statici.

Raccogli e carica risorse statiche

Creare un bucket Cloud Storage e renderlo leggibile pubblicamente.

gsutil mb gs://PROJECT_ID_MEDIA_BUCKET
gsutil defacl set public-read gs://PROJECT_ID_MEDIA_BUCKET

Raccogli tutti i contenuti statici localmente in un'unica cartella:
```
python manage.py collectstatic
```

Carica i contenuti statici su Cloud Storage:

gsutil -m rsync -r ./static gs://PROJECT_ID_MEDIA_BUCKET/static

In mysite/settings.py, imposta il valore STATIC_URL sul seguente URL, sostituendo [YOUR_GCS_BUCKET] con il nome del tuo bucket:
```
http://storage.googleapis.com/PROJECT_ID_MEDIA_BUCKET/static/
```

Configura GKE

Per inizializzare GKE, vai alla pagina Cluster.

Vai alla pagina Cluster

Quando utilizzi GKE per la prima volta in un progetto, devi attendere che Kubernetes Engine sia in fase di preparazione. L'operazione potrebbe richiedere almeno un minuto prima di scomparire.
Crea un cluster GKE:
```
gcloud container clusters create polls \
  --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
  --num-nodes 4 --zone "us-central1-a"
```
Hai ricevuto il messaggio di errore: "Project [PROJECT_ID] non è completamente inizializzato con gli account di servizio predefiniti."?

Inizializza GKE

Se hai ricevuto un errore, vai a Google Cloud Console per inizializzare GKE nel tuo progetto.

Vai alla pagina Cluster

Attendi che Kubernetes Engine si stia preparando. L'operazione può richiedere un minuto o più.
Dopo aver creato il cluster, utilizza lo strumento a riga di comando kubectl, integrato con gcloud, per interagire con il cluster GKE. Dato che gcloud e kubectl sono strumenti separati, assicurati che kubectl sia configurato per interagire con il cluster corretto.
```
gcloud container clusters get-credentials polls --zone "us-central1-a"
```

Configurazione di Cloud SQL

Sono necessari diversi secret per consentire alla tua app GKE di connettersi all'istanza Cloud SQL. uno è necessario per l'accesso a livello di istanza (connessione), mentre gli altri due sono necessari per l'accesso al database. Per ulteriori informazioni sui due livelli di controllo dell'accesso, consulta questo articolo: Controllo dell'accesso alle istanze.
1. Per creare il secret per l'accesso a livello di istanza, specifica il percorso ([PATH_TO_CREDENTIAL_FILE]) della chiave dell'account di servizio JSON che hai scaricato durante la creazione dell'account di servizio (vedi Creazione di un account di servizio):
```
kubectl create secret generic cloudsql-oauth-credentials \
  --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]
```
2. Per creare i secret per l'accesso al database, utilizza il database SQL, il nome utente e la password definiti nel passaggio 2 di Inizializzazione dell'istanza Cloud SQL:
```
kubectl create secret generic cloudsql \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=DATABASE_USERNAME \
  --from-literal=password=DATABASE_PASSWORD
```
Recupera l'immagine Docker pubblica per il proxy Cloud SQL.
```
docker pull b.gcr.io/cloudsql-docker/gce-proxy
```
Crea un'immagine Docker, sostituendo <your-project-id> con l'ID progetto.
```
docker build -t gcr.io/PROJECT_ID/polls .
```
Configura Docker in modo che utilizzi gcloud come assistente per le credenziali, in modo da poter eseguire il push dell'immagine a Container Registry:
```
gcloud auth configure-docker
```
Esegui il push dell'immagine Docker. Sostituisci <your-project-id> con l'ID progetto.
```
docker push gcr.io/PROJECT_ID/polls
```
Nota: questo comando richiede l'accesso in scrittura a Cloud Storage. Se esegui questo tutorial su un'istanza di Compute Engine, il tuo accesso a Cloud Storage potrebbe essere di sola lettura. Per ottenere l'accesso in scrittura, crea un account di servizio e utilizzalo per eseguire l'autenticazione sull'istanza.
Crea la risorsa GKE:
```
kubectl create -f polls.yaml
```
Nota: se hai utilizzato nomi diversi (diverso da cloudsql-oauth-credentials e cloudsql) quando hai creato i secret nei comandi precedenti, devi aggiornare il file polls.yaml in modo che corrisponda a questi nuovi nomi.

Eseguire il deployment dell'app in GKE

Dopo la creazione delle risorse, nel cluster sono presenti tre pod polls. Controlla lo stato dei pod:

kubectl get pods

Attendi alcuni minuti che gli stati dei pod vengano visualizzati come Running. Se i pod non sono pronti o se vedi dei riavvii, puoi ottenere i log per un pod specifico per capire il problema. [YOUR-POD-ID] è una parte dell'output restituito dal comando kubectl get pods precedente.

kubectl logs [YOUR_POD_ID]

Guarda l'app eseguita in Google Cloud

Quando i pod sono pronti, puoi ottenere l'indirizzo IP pubblico del bilanciatore del carico:

kubectl get services polls

Osserva l'indirizzo EXTERNAL-IP e vai su http://[EXTERNAL-IP] nel browser per visualizzare la pagina di destinazione dei sondaggi Django e accedere alla Console di amministrazione.

Comprendere il codice

Applicazione di esempio

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

django-admin startproject mysite
python manage.py startapp polls

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

Configurazione del database

Il tag settings.py contiene la configurazione per il tuo database SQL:

Kubernetes_engine/django_tutorial/mysite/settings.py

Visualizza su GitHub

DATABASES = {
    'default': {
        # If you are using Cloud SQL for MySQL rather than PostgreSQL, set
        # 'ENGINE': 'django.db.backends.mysql' instead of the following.
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.getenv('DATABASE_NAME'),
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Configurazioni dei pod Kubernetes

Il file polls.yaml specifica due risorse Kubernetes. Il primo è il servizio, che definisce un nome coerente e un indirizzo IP privato per l'app web Django. Il secondo è un bilanciatore del carico HTTP con un indirizzo IP esterno rivolto al pubblico.

Kubernetes_engine/django_tutorial/polls.yaml

Visualizza su GitHub

# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://kubernetes.io/docs/concepts/services-networking/service/
# For more information about external HTTP load balancing see:
#   https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls

Il servizio fornisce un nome di rete e un indirizzo IP, mentre i pod GKE eseguono il codice dell'app dietro il servizio. Il file polls.yaml specifica un deployment che fornisce aggiornamenti dichiarativi per i pod GKE. Il servizio indirizza il traffico al deployment abbinando il selettore del servizio all'etichetta del deployment. In questo caso, il selettore polls è associato all'etichetta polls.

Kubernetes_engine/django_tutorial/polls.yaml

Visualizza su GitHub

apiVersion: apps/v1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  selector:
    matchLabels:
      app: polls
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: gcr.io/<your-project-id>/polls
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        env:
            - name: DATABASE_NAME
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: database
            - name: DATABASE_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: gcr.io/cloudsql-docker/gce-proxy:1.16
        name: cloudsql-proxy
        command: ["/cloud_sql_proxy", "--dir=/cloudsql",
                  "-instances=<your-cloudsql-connection-string>=tcp:5432",
                  "-credential_file=/secrets/cloudsql/credentials.json"]
        volumeMounts:
          - name: cloudsql-oauth-credentials
            mountPath: /secrets/cloudsql
            readOnly: true
          - name: ssl-certs
            mountPath: /etc/ssl/certs
          - name: cloudsql
            mountPath: /cloudsql
      volumes:
        - name: cloudsql-oauth-credentials
          secret:
            secretName: cloudsql-oauth-credentials
        - name: ssl-certs
          hostPath:
            path: /etc/ssl/certs
        - name: cloudsql
          emptyDir: {}

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à descritte in questo documento, quando lo elimini elimini anche tutto il 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminare le singole risorse

Se non vuoi eliminare il progetto, elimina le singole risorse.

Elimina il cluster Google Kubernetes Engine:
```
gcloud container clusters delete polls
```
Elimina l'immagine Docker di cui hai eseguito il push a Container Registry:
```
gcloud container images delete gcr.io/PROJECT_ID/polls
```

Elimina l'istanza Cloud SQL:

gcloud sql instances delete INSTANCE_NAME

Passaggi successivi

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

Esecuzione di Django su Google Kubernetes Engine

Obiettivi

Costi

Prima di iniziare

prepara l'ambiente

Clonare un'app di esempio

Linux/macOS

Windows

Conferma la configurazione Python

Linux/macOS

Windows

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

Linux a 64 bit

Linux a 32 bit

macOS a 64 bit

macOS a 32 bit

Mac M1

Windows a 64 bit

Windows a 32 bit

Immagine Docker proxy Cloud SQL Auth

Altro sistema operativo

Crea servizi di supporto

Configurare un'istanza Cloud SQL per PostgreSQL

Console

gcloud

Console

gcloud

Console

gcloud

Crea un account di servizio

Configura le impostazioni del database

Linux/MacOS

Windows

Impostare la configurazione di GKE

Esecuzione dell'applicazione nel computer locale

Linux/macOS

Windows

Linux/macOS

Windows

Utilizzare la Console di amministrazione Django

Eseguire il deployment dell'app in GKE

Raccogli e carica risorse statiche

Configura GKE

Inizializza GKE

Configurazione di Cloud SQL

Eseguire il deployment dell'app in GKE

Guarda l'app eseguita in Google Cloud

Comprendere il codice

Applicazione di esempio

Configurazione del database

Configurazioni dei pod Kubernetes

Esegui la pulizia

Elimina il progetto

Eliminare le singole risorse

Passaggi successivi