Esecuzione di Rails nell'ambiente Cloud Run

Scopri come eseguire il deployment di un'applicazione Rails di esempio in Cloud Run e come integrare database gestiti, spazio di archiviazione di oggetti, secret criptati e pipeline di build con il calcolo serverless.

Il deployment delle applicazioni Rails prevede l'integrazione di più servizi per formare un progetto coeso. Questo tutorial presuppone che tu abbia familiarità con lo sviluppo web Rails.

Questo tutorial richiede Ruby 3.0 o versioni successive e Rails 8 o versioni successive.

Diagramma che mostra l'architettura del deployment.
Il sito Rails viene pubblicato da Cloud Run, che utilizza più servizi di backend per archiviare diversi tipi di dati (informazioni del database relazionale, asset multimediali, secret di configurazione e immagini container). I servizi di backend vengono aggiornati da Cloud Build nell'ambito di un'attività di build e migrazione.

Obiettivi

  • Crea e connetti un database Cloud SQL ad Active Record
  • Crea e utilizza Secret Manager per archiviare e accedere in modo sicuro a una chiave master di Rails
  • Ospitare file multimediali e file caricati dagli utenti su Cloud Storage da Active Storage
  • Utilizza Cloud Build per automatizzare le build e le migrazioni di database
  • Esegui il deployment di un'app Rails in Cloud Run

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 Run, Cloud SQL, Cloud Build, Secret Manager, 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 Google Cloud 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 Run, Cloud SQL, Cloud Build, Secret Manager, 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 Google Cloud 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
  14. Assicurati che l'account utilizzato per questo tutorial disponga di autorizzazioni sufficienti.

prepara l'ambiente

Questo tutorial utilizza diversi Google Cloud servizi per fornire il database, l'archiviazione dei contenuti multimediali e l'archiviazione dei secret che supportano l'applicazione Rails di cui è stato eseguito il deployment. Prepara l'ambiente configurando una regione in cui eseguire il deployment dei servizi e clonando l'app Rails.

Imposta il progetto e la regione predefiniti

  1. Imposta la configurazione del progetto predefinita per gcloud CLI eseguendo il seguente comando:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con l'ID progetto Google Cloud.

  2. Configura la regione:

    export REGION=REGION

    Sostituisci REGION con una posizione appropriata. Per 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 località.

Clona l'app Rails

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

  1. Clona il repository:

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

  2. Vai alla directory che contiene il codice campione ed esegui questi comandi per assicurarti che l'applicazione sia configurata correttamente con i gem e le dipendenze richiesti:

    Linux/macOS

    cd ruby-docs-samples/run/rails
bundle install

    Windows

    cd ruby-docs-samples\run\rails
bundle install

Prepara i servizi di supporto

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

Configura un'istanza Cloud SQL per PostgreSQL

Rails supporta più database relazionali, tra cui diversi offerti da Cloud SQL. Questo tutorial utilizza PostgreSQL, un database open source comunemente utilizzato dalle app Rails.

Le sezioni seguenti descrivono la creazione di un'istanza, un database e un utente del database PostgreSQL per la tua app Rails.

Crea un'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. Nel campo ID istanza, inserisci un nome per l'istanza (INSTANCE_NAME).

  5. Nel campo Password, inserisci una password per l'utente postgres.

  6. Utilizza i valori predefiniti per gli altri campi.

  7. Fai clic su Crea istanza.

gcloud

  • Crea l'istanza PostgreSQL:

    gcloud sql instances create INSTANCE_NAME \
    --database-version POSTGRES_12 \
    --tier db-f1-micro \
    --region REGION

    Sostituisci quanto segue:

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

Crea un database

Console

  1. Nella console Google Cloud , vai alla pagina Istanze Cloud SQL.

    Vai alla pagina Istanze Cloud SQL

  2. Seleziona l'istanza INSTANCE_NAME.

  3. Vai alla scheda Database.

  4. Fai clic su Crea database.

  5. Nella finestra di dialogo Nome database, inserisci DATABASE_NAME.

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

Crea un utente

Genera una password casuale per l'utente del database e scrivila in un file denominato dbpassword:

cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 50 | head -n1 > dbpassword

Console

  1. Nella console Google Cloud , vai alla pagina Istanze Cloud SQL.

    Vai alla pagina Istanze Cloud SQL

  2. Seleziona l'istanza INSTANCE_NAME.

  3. Vai alla scheda Utenti.

  4. Fai clic su Aggiungi account utente.

  5. Nella finestra di dialogo Autenticazione integrata:

    1. Inserisci il nome utente DATABASE_USERNAME.
    2. Inserisci il contenuto del file dbpassword come password PASSWORD.

  6. Fai clic su Aggiungi.

gcloud

  • Crea l'utente all'interno dell'istanza appena creata e imposta la relativa password in modo che corrisponda al contenuto di dbpassword:

    gcloud sql users create DATABASE_USERNAME \
   --instance=INSTANCE_NAME --password=$(cat dbpassword)

    Sostituisci DATABASE_USERNAME con un nome per l'utente all'interno dell'istanza.

Configura un repository Artifact Registry

Utilizza Artifact Registry per creare un repository in cui archiviare l'immagine container.

Console

  1. Nella console Google Cloud , vai alla pagina Artifact Registry.

    Vai ad Artifact Registry

  2. Fai clic su Crea repository.

  3. Inserisci quanto segue:

    • In Nome, inserisci "cloud-run-source-deploy".
    • Per Formato, seleziona "Docker".
    • In Regione, seleziona REGION.

  4. Mantieni i valori predefiniti per gli altri campi.

  5. Fai clic su Crea.

gcloud

  • Crea un repository Artifact Registry:

    gcloud artifacts repositories create cloud-run-source-deploy \
    --repository-format docker \
    --location REGION

Configura un bucket Cloud Storage

Puoi ospitare asset statici Rails e contenuti multimediali caricati dagli utenti in un'archiviazione di oggetti ad alta affidabilità utilizzando Cloud Storage.

Console

  1. Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

    Vai a Bucket

  2. Fai clic su Crea.
  3. Nella pagina Crea un bucket, inserisci le informazioni del bucket. Per andare al passaggio successivo, fai clic su Continua.
    1. Nella sezione Inizia, segui questi passaggi:
    2. In Località, seleziona quanto segue: us-central1
    3. Nella sezione Scegli come archiviare i tuoi dati, segui questi passaggi:
      1. Nella sezione Impostare una classe predefinita, seleziona quanto segue: Standard.
      2. Per attivare lo spazio dei nomi gerarchico, nella sezione Ottimizza l'archiviazione per workload con uso intensivo dei dati, seleziona Abilita uno spazio dei nomi gerarchico in questo bucket.
    4. Nella sezione Scegli come controllare l'accesso agli oggetti, seleziona se il bucket applica o meno la prevenzione dell'accesso pubblico e seleziona un metodo di controllo dell'accesso per gli oggetti del bucket.
    5. Nella sezione Scegli come proteggere i dati degli oggetti, segui questi passaggi:
      • Seleziona una delle opzioni in Protezione dei dati che vuoi impostare per il bucket.
        • Per attivare l'eliminazione temporanea, fai clic sulla casella di controllo Criterio di eliminazione temporanea (per il recupero dei dati) e specifica il numero di giorni per cui vuoi conservare gli oggetti dopo l'eliminazione.
        • Per impostare il controllo delle versioni degli oggetti, seleziona la casella di controllo Controllo delle versioni degli oggetti (per il controllo delle versioni) e specifica il numero massimo di versioni per oggetto e il numero di giorni dopo i quali scadono le versioni non correnti.
        • Per abilitare il criterio di conservazione su oggetti e bucket, seleziona la casella di controllo Conservazione (per la conformità), quindi procedi nel seguente modo:
          • Per attivare il blocco della conservazione degli oggetti, fai clic sulla casella di controllo Abilita conservazione degli oggetti.
          • Per attivare Bucket Lock, fai clic sulla casella di controllo Imposta criterio di conservazione del bucket e scegli un'unità di tempo e una durata per il periodo di conservazione.
      • Per scegliere come verranno criptati i dati degli oggetti, espandi la sezione Crittografia dei dati () e seleziona un metodo di crittografia dei dati.
  4. Fai clic su Crea.

gcloud

  • Creare un bucket Cloud Storage. Per creare un nome di bucket Cloud Storage univoco, utilizza PROJECT_ID e un suffisso a tua scelta, MEDIA_BUCKET_SUFFIX. In Cloud Storage, i nomi dei bucket devono essere univoci a livello globale.

    gcloud storage buckets create gs://PROJECT_ID-MEDIA_BUCKET_SUFFIX \
    --location=REGION

Dopo aver creato un bucket, per rendere pubbliche le immagini caricate, modifica le autorizzazioni degli oggetti immagine in modo che siano leggibili da tutti.

Console

  1. Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

    Vai a Bucket

  2. Nell'elenco dei bucket, fai clic sul nome del bucket che vuoi rendere pubblico.

  3. Seleziona la scheda Autorizzazioni nella parte superiore della pagina.

  4. Fai clic sul pulsante Aggiungi membri.

    Viene visualizzata la finestra di dialogo Aggiungi membri.

  5. Nel campo Nuovi membri, inserisci allUsers.

  6. Nel menu a discesa Seleziona un ruolo, seleziona il sottomenu Cloud Storage e fai clic sull'opzione Visualizzatore oggetti Storage.

  7. Fai clic su Salva.

Dopo la condivisione pubblica, nella colonna Accesso pubblico viene visualizzata un'icona link per ogni oggetto. Puoi fare clic su questa icona per ottenere l'URL dell'oggetto.

Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni Ruby non riuscite nella console Google Cloud , consulta Risoluzione dei problemi.

gcloud

  • Utilizza il comando gcloud storage buckets add-iam-policy-binding per rendere pubblici tutti gli oggetti. Utilizza il valore per MEDIA_BUCKET_SUFFIX che hai utilizzato quando hai creato il bucket.

    gcloud storage buckets add-iam-policy-binding gs://PROJECT_ID-MEDIA_BUCKET_SUFFIX \
    --member=allUsers --role=roles/storage.objectViewer

Archivia i valori dei secret in Secret Manager

Ora che i servizi di backend sono configurati, Rails ha bisogno di informazioni sicure, come le password, per accedere a questi servizi. Anziché inserire questi valori direttamente nel codice sorgente di Rails, questo tutorial utilizza Rails Credentials e Secret Manager per archiviare queste informazioni in modo sicuro.

Crea un file delle credenziali criptato e archivia la chiave come secret di Secret Manager

Rails archivia i segreti in un file criptato denominato "config/credentials.yml.enc". Il file può essere decriptato con config/master.key locale o con la variabile di ambiente ENV["RAILS_MASTER_KEY"]. Nel file delle credenziali puoi archiviare la password del database dell'istanza Cloud SQL e altre chiavi di accesso per le API esterne.

Puoi archiviare questa chiave in modo sicuro in Secret Manager. Poi puoi concedere l'accesso alla chiave a Cloud Run e Cloud Build concedendo l'accesso ai rispettivi service account. I service account sono identificati da un indirizzo email che contiene il numero di progetto.

  1. Genera il file config/credentials.yml.enc con il seguente comando:

    bin/rails credentials:edit

    Il comando creerà un config/master.key se non è definita alcuna chiave master e creerà un file config/credentials.yml.enc se il file non esiste. Si aprirà un file temporaneo nel tuo $EDITOR predefinito con i contenuti decriptati dei secret da aggiungere.

  2. Copia e incolla la password del database dell'istanza PostgreSQL appena creata dal file dbpassword nel file delle credenziali:

    secret_key_base: GENERATED_VALUE
gcp:
    db_password: PASSWORD

    È possibile accedere ai secret con Rails.application.credentials. Ad esempio, Rails.application.credentials.secret_key_base dovrebbe restituire la base della chiave segreta dell'applicazione e Rails.application.credentials.gcp[:db_password] dovrebbe restituire la password del database.

  3. config/credentials/yml.enc è archiviato in forma criptata, ma config/master.key può essere archiviato in Secret Manager.

    Console

    1. Nella console Google Cloud , vai alla pagina Secret Manager.

      Vai alla pagina Secret Manager

    2. Fai clic su Crea secret.

    3. Nel campo Nome, inserisci un nome per il secret RAILS_SECRET_NAME.

    4. Nella finestra di dialogo Valore secret, incolla il valore di mater.key nella casella.

    5. Fai clic su Crea secret.

    6. Nella pagina dei dettagli del secret, annota il numero di progetto:

      projects/PROJECTNUM/secrets/RAILS_SECRET_NAME

    7. Nella scheda Autorizzazioni, fai clic su Aggiungi membro.

    8. Nel campo Nuovi membri, inserisci PROJECTNUM-compute@developer.gserviceaccount.com e poi premi Enter.

    9. Nel campo Nuovi membri, inserisci PROJECTNUM@cloudbuild.gserviceaccount.com e poi premi Enter.

    10. Nel menu a discesa Ruolo, seleziona Secret Manager Secret Accessor.

    11. Fai clic su Salva.

    gcloud

    1. Crea un nuovo secret con il valore di config/master.key:

      gcloud secrets create RAILS_SECRET_NAME --data-file config/master.key

      Sostituisci RAILS_SECRET_NAME con un nome per il nuovo secret.

    2. Per confermare la creazione del secret, controllalo:

      gcloud secrets describe RAILS_SECRET_NAME

gcloud secrets versions access latest --secret RAILS_SECRET_NAME

    3. Ottieni il valore del numero di progetto:

      gcloud projects describe PROJECT_ID --format='value(projectNumber)'

    4. Concedi l'accesso al secret all'account di servizio Cloud Run:

      gcloud secrets add-iam-policy-binding RAILS_SECRET_NAME \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

      Sostituisci PROJECTNUM con il valore del numero di progetto.

    5. Concedi l'accesso al secret al account di servizio Cloud Build:

      gcloud secrets add-iam-policy-binding RAILS_SECRET_NAME \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

      Nell'output, verifica che bindings elenchi i due service account come membri.

Connetti l'app Rails al database di produzione e allo spazio di archiviazione

Questo tutorial utilizza un'istanza PostgreSQL come database di produzione e Cloud Storage come backend di archiviazione. Per consentire a Rails di connettersi al database e al bucket di archiviazione appena creati, devi specificare tutte le informazioni necessarie per accedervi nel file .env. Il file .env contiene la configurazione per le variabili di ambiente dell'applicazione. L'applicazione leggerà questo file utilizzando il Gem dotenv. Poiché i secret sono archiviati in credentials.yml.enc e Secret Manager, .env non deve essere criptato perché non contiene credenziali sensibili.

  1. Per configurare l'app Rails in modo che si connetta al database e al bucket di archiviazione, apri il file .env.

  2. Modifica la configurazione del file .env come segue. Utilizza il valore di MEDIA_BUCKET_SUFFIX che hai utilizzato quando hai creato il bucket.

    PRODUCTION_DB_NAME: DATABASE_NAME
PRODUCTION_DB_USERNAME: DATABASE_USERNAME
CLOUD_SQL_CONNECTION_NAME: PROJECT_ID:REGION:INSTANCE_NAME
GOOGLE_PROJECT_ID: PROJECT_ID
STORAGE_BUCKET_NAME: PROJECT_ID-MEDIA_BUCKET_SUFFIX

    L'app Rails è ora configurata per utilizzare Cloud SQL e Cloud Storage durante il deployment su Cloud Run.

esegui il deployment dell'app in Cloud Run

Ora che i servizi di backend sono configurati, puoi eseguire il deployment dell'app come servizio Cloud Run.

  1. Utilizzando cloudbuild.yaml fornito, utilizza Cloud Build per creare l'immagine, eseguire le migrazioni del database e popolare gli asset statici:

    gcloud builds submit --config cloudbuild.yaml \
    --substitutions _SERVICE_NAME=SERVICE_NAME,_INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION,_SECRET_NAME=RAILS_SECRET_NAME

    Sostituisci SERVICE_NAME con il nome del servizio. Il completamento della prima build richiede alcuni minuti. Se la build è scaduta, aumenta la durata del timeout inserendo --timeout=2000s nel comando di build.

  2. Quando la build ha esito positivo, esegui il deployment del servizio Cloud Run per la prima volta, impostando la regione del servizio, l'immagine di base e l'istanza Cloud SQL connessa:

    gcloud run deploy SERVICE_NAME \
        --region REGION \
        --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/SERVICE_NAME \
        --add-cloudsql-instances PROJECT_ID:REGION:INSTANCE_NAME \
        --allow-unauthenticated

    Dovresti visualizzare un output che mostra che il deployment è riuscito, con un URL del servizio.

  3. Per visualizzare il servizio di cui è stato eseguito il deployment, vai all'URL del servizio.

    Pagina di destinazione dell'album di gatti.
    Se l'URL del servizio mostra Album di foto di gatti, ti trovi nella home page dell'app.

  4. Prova a caricare una nuova foto. Se la foto viene caricata correttamente, l'applicazione Rails è stata implementata correttamente.

    Esempio di elemento dell'album di gatti
    Se l'URL del servizio mostra Album di foto di gatti, ti trovi nella home page dell'app.

Aggiorna l'applicazione

Sebbene i passaggi iniziali di provisioning e deployment fossero complessi, l'esecuzione degli aggiornamenti è un processo più semplice:

  1. Esegui lo script di build e migrazione di Cloud Build:

    gcloud builds submit --config cloudbuild.yaml \
        --substitutions _SERVICE_NAME=SERVICE_NAME,_INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION,_SECRET_NAME=RAILS_SECRET_NAME

  2. Esegui il deployment del servizio, specificando solo la regione e l'immagine:

    gcloud run deploy SERVICE_NAME \
        --region REGION \
        --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/SERVICE_NAME

comprendi il codice

L'app di esempio Rails è stata creata utilizzando i comandi Rails standard. I seguenti comandi creano l'app cat_album e utilizzano il comando scaffold per generare un modello, un controller e le visualizzazioni per la risorsa Photo:

rails new cat_album
rails generate scaffold Photo caption:text

Connessione al database

Il file config/database.yml contiene la configurazione necessaria per accedere ai database in diversi ambienti (sviluppo, test, produzione). Ad esempio, il database di produzione è configurato per l'esecuzione in Cloud SQL per PostgreSQL. Il nome e il nome utente del database vengono impostati tramite variabili di ambiente nel file .env, mentre la password del database viene memorizzata all'interno del file config/credentials.yml.enc, che richiede RAILS_MASTER_KEY per la decriptazione.

Quando l'app viene eseguita su Cloud Run (completamente gestito), si connette all'istanza PostgreSQL utilizzando un socket fornito dall'ambiente Cloud Run. Quando l'app viene eseguita sulla macchina locale, si connette all'istanza PostgreSQL utilizzando il proxy di autenticazione Cloud SQL.

production:
  <<: *default
  database: <%= ENV["PRODUCTION_DB_NAME"] %>
  username: <%= ENV["PRODUCTION_DB_USERNAME"] %>
  password: <%= Rails.application.credentials.gcp[:db_password] %>
  host: "<%= ENV.fetch("DB_SOCKET_DIR") { '/cloudsql' } %>/<%= ENV["CLOUD_SQL_CONNECTION_NAME"] %>"

Contenuti multimediali caricati dagli utenti archiviati sul cloud

Rails utilizza Active Storage per caricare file sui fornitori di spazio di archiviazione. I file config/storage.yml e config/environments/production.rb specificano Cloud Storage come fornitore di servizi nell'ambiente di produzione.

google:
  service: GCS
  project: <%= ENV["GOOGLE_PROJECT_ID"] %>
  bucket: <%= ENV["STORAGE_BUCKET_NAME"] %>
 
# Store uploaded files on the local file system (see config/storage.yml for options).
config.active_storage.service = :google

Automation con Cloud Build

Il file cloudbuild.yaml esegue non solo i passaggi tipici di creazione dell'immagine (creazione dell'immagine container e push su Artifact Registry), ma anche le migrazioni del database Rails. Questa migrazione viene eseguita utilizzando i job Cloud Run, in cui viene utilizzato un comando personalizzato in modo che il container esegua la migrazione, anziché il server web predefinito.

steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    entrypoint: 'bash'
    args: ["-c", "docker build --build-arg MASTER_KEY=$$RAILS_KEY -t ${_IMAGE_NAME} . "]
    secretEnv: ["RAILS_KEY"]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "${_IMAGE_NAME}"]

  - id: "apply migrations"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: /bin/bash
    secretEnv: ["RAILS_KEY"]
    args:
      - "-c"
      - |
        gcloud run jobs create migrate-job \
          --region ${_REGION} \
          --image ${_IMAGE_NAME} \
          --set-cloudsql-instances ${_CLOUD_SQL_CONNECTION_NAME} \
          --set-env-vars RAILS_MASTER_KEY=$$RAILS_KEY \
          --command bundle \
          --args exec,rails,db:migrate \
          --execute-now --wait && \
          gcloud run jobs delete  migrate-job --region ${_REGION} -q

options:
  dynamicSubstitutions: true

substitutions:
  _REGION: us-central1
  _SERVICE_NAME: rails-cat-album
  _INSTANCE_NAME: cat-album
  _SECRET_NAME: rails-master-key
  _AR_REPO_NAME: cloud-run-source-deploy
  _IMAGE_NAME: ${_REGION}-docker.pkg.dev/${PROJECT_ID}/${_AR_REPO_NAME}/${_SERVICE_NAME}
  _CLOUD_SQL_CONNECTION_NAME: ${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}

availableSecrets:
  secretManager:
  - versionName: projects/${PROJECT_ID}/secrets/${_SECRET_NAME}/versions/latest
    env: RAILS_KEY

images:
  - "${_IMAGE_NAME}"

In questa configurazione vengono utilizzate le variabili di sostituzione. La modifica diretta dei valori nel file comporta la possibilità di eliminare il flag --substitutions al momento della migrazione.

In questa configurazione, vengono applicate solo le migrazioni esistenti nella directory db/migrate. Per creare file di migrazione, vedi Active Record Migrations.

Per creare l'immagine e applicare le migrazioni, la configurazione di Cloud Build deve accedere al secret RAILS_MASTER_KEY da Secret Manager. Il campo availableSecrets imposta la versione del secret e le variabili di ambiente da utilizzare per il secret. Il secret della chiave master viene passato come argomento nel passaggio dell'immagine di build e poi viene impostato come RAILS_MASTER_KEY nel Dockerfile durante la creazione dell'immagine.

ARG MASTER_KEY
ENV RAILS_MASTER_KEY=${MASTER_KEY}

Per estendere la configurazione di compilazione di Cloud Build in modo da includere il deployment in un'unica configurazione senza dover eseguire due comandi, consulta Deployment continuo da Git con Cloud Build. Ciò richiede modifiche a IAM, come descritto.

Esegui la pulizia

  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.