Esecuzione di Django su Google Kubernetes Engine

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

Questo tutorial presuppone che tu abbia familiarità con lo sviluppo web Django. Se non hai mai sviluppato con Django, ti consigliamo di seguire la procedura per scrivere la tua prima app Django prima di continuare.

Sebbene questo tutorial mostri Django in modo specifico, puoi utilizzare questa procedura di deployment con altri framework basati su Django, come Wagtail e Django CMS.

Questo tutorial utilizza Django 5, che richiede almeno Python 3.10.

Devi anche aver installato Docker.

Obiettivi

In questo tutorial, imparerai a:

  • Crea e connetti un database Cloud SQL.
  • Crea e utilizza i valori dei secret di Kubernetes.
  • Esegui il deployment di un'app Django in Google Kubernetes 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 potrebbero avere diritto a una prova senza costi.

Prima di iniziare

  1. 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 senza costi per l'esecuzione, il test e il deployment dei workload.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud SQL, GKE and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. Installa gcloud CLI.

  6. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  7. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the Cloud SQL, GKE and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  11. Installa gcloud CLI.

  12. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  13. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

prepara l'ambiente

Clona un'app di esempio

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

  1. Puoi scaricare l'esempio come file ZIP ed estrarlo o clonare il repository sulla tua macchina locale:

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

  2. 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 di Python

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

Per maggiori dettagli, consulta la guida all'ambiente di sviluppo Python.

  1. Verifica che Python sia almeno alla versione 3.10.

     python -V

    Dovresti visualizzare Python 3.10.0 o un valore superiore.

  2. 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, la tua app utilizza il proxy di autenticazione Cloud SQL integrato nell'ambiente Google Kubernetes Engine per comunicare con l'istanza Cloud SQL. Tuttavia, per testare l'app localmente, devi installare e utilizzare una copia locale del proxy nel tuo ambiente di sviluppo. Per ulteriori 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, è necessaria l'autenticazione dell'applicazione tramite gcloud CLI.

  1. Autenticati e acquisisci le credenziali per l'API:

    gcloud auth application-default login

  2. 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.21.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.21.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.21.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.21.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 tasto destro del mouse su https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x64.exe e seleziona Salva link con nome per scaricare il proxy di autenticazione Cloud SQL. Rinomina il file in cloud-sql-proxy.exe.

    Windows a 32 bit

    Fai clic con il tasto destro del mouse su https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x86.exe e seleziona Salva link con nome per scaricare il proxy di autenticazione Cloud SQL. Rinomina il file in 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 del container del proxy di autenticazione Cloud SQL predefinita utilizza distroless, che non contiene alcuna shell. Se hai bisogno di una shell o di strumenti correlati, scarica un'immagine basata su alpine o buster. Per maggiori informazioni, vedi Immagini container del proxy di autenticazione Cloud SQL.

    Puoi eseguire il pull dell'ultima immagine sulla tua macchina locale utilizzando Docker con il seguente comando:

    docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.1

    Altri sistemi operativi

    Per altri sistemi operativi non inclusi qui, puoi compilare il proxy di autenticazione Cloud SQL dal codice sorgente.

    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 località scelta quando utilizzi i comandi cloud-sql-proxy.

Crea servizi di backend

Questo tutorial utilizza diversi servizi Google Cloud per fornire il database, l'archiviazione dei contenuti multimediali e l'archiviazione dei secret che supportano il progetto Django di cui è stato eseguito il deployment. Questi servizi vengono implementati in una regione specifica. Per l'efficienza tra i servizi, tutti i servizi devono essere implementati nella stessa regione. Per saperne di più sulla regione più vicina a te, consulta Prodotti disponibili per regione.

Configura un'istanza Cloud SQL per PostgreSQL

Django supporta ufficialmente più database relazionali, ma offre il massimo 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 PostgreSQL, di un database e di un utente del database per l'app.

  1. 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 Scegli PostgreSQL.

    4. Per Versione SQL, scegli "Enterprise".

    5. Per Preset versione, scegli "Sandbox".

    6. Nel campo ID istanza, inserisci INSTANCE_NAME.

    7. Inserisci una password per l'utente postgres.

    8. Mantieni i valori predefiniti per gli altri campi.

    9. Fai clic su Crea istanza.

    L'istanza sarà pronta per l'uso dopo qualche minuto.

    gcloud

    • Crea l'istanza PostgreSQL:

      gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_16 \
    --tier db-n1-standard-2 \
    --region REGION

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome dell'istanza Cloud SQL
    • PROJECT_ID: l' Google Cloud ID progetto
    • REGION: la Google Cloud regione

    La creazione dell'istanza e la sua preparazione all'uso richiedono alcuni minuti.

  2. 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 appena creata:

      gcloud sql databases create DATABASE_NAME \
    --instance INSTANCE_NAME

      Sostituisci DATABASE_NAME con un nome per il database all'interno dell'istanza.

  3. Crea un 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 Scegli la modalità di autenticazione nella sezione "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 appena creata:

      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 la tua istanza Cloud SQL. Per saperne di più sui service account, consulta la panoramica dell'autenticazione.Google Cloud

  1. Nella Google Cloud console, vai alla pagina Service account.

    Vai ad Account di servizio

  2. Seleziona il progetto che contiene l'istanza di Cloud SQL.
  3. Fai clic su Crea account di servizio.
  4. Nel campo Nome service account, inserisci un nome descrittivo per il account di servizio.
  5. Modifica l'ID service account con un valore univoco e riconoscibile, quindi fai clic su Crea e continua.
  6. Fai clic sul campo Seleziona un ruolo e seleziona uno dei seguenti ruoli:
    • Cloud SQL > Client Cloud SQL
    • Cloud SQL > Cloud SQL Editor
    • Cloud SQL > Amministratore Cloud SQL

  7. Fai clic su Fine per completare la creazione del service account.
  8. Fai clic sul menu delle azioni per il nuovo account di servizio e seleziona Gestisci chiavi.
  9. Fai clic sul menu a discesa Aggiungi chiave, quindi su Crea nuova chiave.
  10. Verifica che il tipo di chiave sia JSON e fai clic su Crea.

    Il file della chiave privata viene scaricato sulla tua macchina. Puoi spostarlo in un'altra posizione. Mantieni al sicuro il file della chiave.

Configurare le impostazioni del database

Utilizza i seguenti comandi 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

Configura la configurazione di GKE

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

  2. Esegui questo comando e annota il valore di connectionName:

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

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

Esecuzione dell'applicazione nel computer locale

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

  1. 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 in esecuzione il proxy di autenticazione Cloud SQL per tutto il tempo in cui testi l'app in locale. L'esecuzione di questo processo in un terminale separato ti consente di continuare a lavorare mentre il processo è in esecuzione.

  2. Nel terminale originale, imposta l'ID progetto localmente:

    Linux/macOS

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Windows

    set GOOGLE_CLOUD_PROJECT=PROJECT_ID

  3. 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

  4. Avvia il server web Django:

    python manage.py runserver 8080

  5. Nel browser, vai alla pagina http://localhost:8080.

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

    Nella pagina viene visualizzato il seguente testo: "Hello, world. Ti trovi nell'indice dei sondaggi". Il server web Django in esecuzione sul tuo computer fornisce le pagine dell'app di esempio.

  6. 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 superutente. Poiché hai una connessione al database accessibile localmente, puoi eseguire i comandi di gestione:

  1. Crea un superuser. Ti verrà chiesto di inserire un nome utente, un indirizzo email e una password.

    python manage.py createsuperuser

  2. Avvia un server web locale:

    python manage.py runserver

  3. Nel browser, vai all'indirizzo http://localhost:8000/admin.

  4. Accedi al sito di amministrazione utilizzando il nome utente e la password che hai utilizzato quando hai eseguito createsuperuser.

Esegui il deployment dell'app in GKE

Quando l'app viene implementata in Google Cloud, utilizza il server Gunicorn. Gunicorn non pubblica contenuti statici, quindi l'app utilizza Cloud Storage per pubblicare contenuti statici.

Raccogliere e caricare risorse statiche

  1. Crea un bucket Cloud Storage e rendilo pubblicamente leggibile.

    gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET
gcloud storage buckets add-iam-policy-binding gs://PROJECT_ID_MEDIA_BUCKET --member=allUsers role=roles/storage.legacyObjectReader

  2. Raccogli tutti i contenuti statici localmente in una cartella:

    python manage.py collectstatic

  3. Carica i contenuti statici su Cloud Storage:

    gcloud storage rsync ./static gs://PROJECT_ID_MEDIA_BUCKET/static --recursive

  4. In mysite/settings.py, imposta il valore di 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

  1. Per inizializzare GKE, vai alla pagina Cluster.

    Vai alla pagina Cluster

    Quando utilizzi GKE per la prima volta in un progetto, devi attendere il messaggio "Kubernetes Engine si sta preparando. Potrebbe essere necessario un minuto o più prima che il messaggio "L'operazione potrebbe richiedere un minuto o più" scompaia.

  2. 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"

    Se viene visualizzato un messaggio di errore simile a Project is not fully initialized with the default service accounts, potresti dover inizializzare Google Kubernetes Engine.

    Inizializza GKE

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

    Vai alla pagina Cluster

    Attendi il messaggio "Kubernetes Engine is getting ready. L'operazione può richiedere un minuto o più".

  3. Dopo aver creato il cluster, utilizza lo strumento a riga di comando kubectl, che è integrato con gcloud CLI, per interagire con il tuo cluster GKE. Poiché 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"

Configura Cloud SQL

  1. Per consentire alla tua app GKE di connettersi alla tua istanza Cloud SQL, hai bisogno di diversi secret. Una è necessaria per l'accesso a livello di istanza (connessione), mentre le altre due sono necessarie per l'accesso al database. Per saperne di più sui due livelli di controllo dell'accesso dell'accesso, consulta Controllo dell'accesso alle istanze.

    1. Per creare il secret per l'accesso a livello di istanza, fornisci la posizione, 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 service account):

      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 durante la creazione dei servizi di backend. Consulta Configura un'istanza Cloud SQL per PostgreSQL:

      kubectl create secret generic cloudsql \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=DATABASE_USERNAME \
  --from-literal=password=DATABASE_PASSWORD

  2. Recupera l'immagine Docker pubblica per il proxy Cloud SQL.

    docker pull b.gcr.io/cloudsql-docker/gce-proxy

  3. Crea un'immagine Docker, sostituendo <your-project-id> con l'ID progetto.

    docker build -t gcr.io/PROJECT_ID/polls .

  4. Configura Docker per utilizzare gcloud come assistente alle credenziali, in modo da poter eseguire il push dell'immagine su Container Registry:

    gcloud auth configure-docker

  5. Esegui il push dell'immagine Docker. Sostituisci <your-project-id> con l'ID progetto.

    docker push gcr.io/PROJECT_ID/polls

  6. Crea la risorsa GKE:

    kubectl create -f polls.yaml

Esegui 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 qualche minuto perché gli stati dei pod vengano visualizzati come Running. Se i pod non sono pronti o se vedi riavvii, puoi ottenere i log di un pod specifico per capire il problema. [YOUR-POD-ID] fa parte dell'output restituito dal comando kubectl get pods precedente.

kubectl logs [YOUR_POD_ID]

Vedi l'app in esecuzione in Google Cloud

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

kubectl get services polls

Prendi nota dell'indirizzo EXTERNAL-IP e vai a http://[EXTERNAL-IP] nel browser per visualizzare la pagina di destinazione dei sondaggi Django e accedere alla console di amministrazione.

comprendi il codice

Applicazione di esempio

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

django-admin startproject mysite
python manage.py startapp polls

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

Configurazione database

settings.py contiene la configurazione del database SQL:

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 e un indirizzo IP interno coerenti per l'app web Django. Il secondo è un bilanciatore del carico HTTP con un indirizzo IP esterno rivolto al pubblico.

# 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 e 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 corrisponde all'etichetta polls.

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

  1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona quello che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le singole risorse

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

  1. Elimina il cluster Google Kubernetes Engine:

    gcloud container clusters delete polls

  2. Elimina l'immagine Docker di cui hai eseguito il push in Container Registry:

    gcloud container images delete gcr.io/PROJECT_ID/polls

  3. Elimina l'istanza Cloud SQL:

    gcloud sql instances delete INSTANCE_NAME

Passaggi successivi