Rails in der Cloud Run-Umgebung

Erfahren Sie, wie Sie eine Beispiel-Rails-Anwendung in Cloud Run bereitstellen und verwaltete Datenbanken, Objektspeicher, verschlüsselte Secrets und Build-Pipelines in serverloses Computing einbinden.

Für die Bereitstellung von Rails-Anwendungen sind mehrere Dienste erforderlich, um ein zusammenhängendes Projekt zu erstellen. In dieser Anleitung wird davon ausgegangen, dass Sie mit der Rails-Webentwicklung vertraut sind.

Für diese Anleitung sind Ruby 3.0 oder höher (Ruby 2.7 wird ebenfalls unterstützt, siehe Abschnitt "Code") und Rails 6 oder höher erforderlich.

Diagramm der Architektur der Bereitstellung.
Die Rails-Website wird von Cloud Run bereitgestellt, das mehrere Sicherungsdienste verwendet, um verschiedene Datentypen (relationale Datenbankinformationen, Medien-Assets, Konfigurations-Secrets und Container-Images). Die Back-End-Dienste werden von Cloud Build als Teil einer Build- und Migrationsaufgabe aktualisiert.

Lernziele

  • Cloud SQL-Datenbank erstellen und mit ActiveRecord verbinden
  • Secret Manager erstellen und verwenden, um einen Rails-Masterschlüssel sicher zu speichern und darauf zuzugreifen
  • Von Nutzern hochgeladene Medien und Dateien in Cloud Storage aus Active Storage hosten
  • Mit Cloud Build Build- und Datenbankmigrationen automatisieren
  • Rails-Anwendung für Cloud Run bereitstellen

Kosten

Hinweis

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

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

    Go to project selector

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

  4. Enable the Cloud Run, Cloud SQL, Cloud Build, Secret Manager, and Compute Engine APIs.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init

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

    Go to project selector

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

  9. Enable the Cloud Run, Cloud SQL, Cloud Build, Secret Manager, and Compute Engine APIs.

    Enable the APIs

  10. Install the Google Cloud CLI.

  11. To initialize the gcloud CLI, run the following command: 

    gcloud init
  12. Achten Sie darauf, dass das für diese Anleitung verwendete Konto über ausreichende Berechtigungen verfügt.

Umgebung vorbereiten

Standardprojekt festlegen

Legen Sie die Standardprojektkonfiguration für die gcloud CLI fest, indem Sie den folgenden Befehl ausführen:

gcloud config set project PROJECT_ID

Ersetzen Sie PROJECT_ID durch Ihre neu erstellte Google Cloud-Projekt-ID.

Rails-Anwendung klonen

Der Code für die Rails-Beispiel-App befindet sich im Repository GoogleCloudPlatform/ruby-docs-samples auf GitHub.

  1. Klonen Sie das Repository:

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

  2. Gehen Sie zum Verzeichnis mit dem Beispielcode und führen Sie die folgenden Befehle aus, um sicherzustellen, dass die Anwendung ordnungsgemäß mit den erforderlichen Gems und Abhängigkeiten eingerichtet ist:

    Linux/macOS

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

    Windows

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

Sicherungsdienste vorbereiten

In dieser Anleitung werden verschiedene Google Cloud-Dienste verwendet, die die Datenbank, den Medienspeicher und den Secret-Speicher bereitstellen, die das bereitgestellte Rails-Projekt unterstützen. Diese Dienste werden in einer bestimmten Region bereitgestellt. Für Effizienz zwischen Diensten ist es am besten, dass alle Dienste in derselben Region bereitgestellt werden. Weitere Informationen zur nächstgelegenen Region finden Sie unter Produktverfügbarkeit nach Region.

Cloud SQL for PostgreSQL-Instanz einrichten

Rails unterstützt mehrere relationale Datenbanken, von denen mehrere von Cloud SQL angeboten werden. In dieser Anleitung wird PostgreSQL verwendet, eine Open-Source-Datenbank, die häufig von Rails-Anwendungen verwendet wird.

In den folgenden Abschnitten wird das Erstellen einer PostgreSQL-Instanz, einer Datenbank und eines Datenbanknutzers für Ihre Rails-Anwendung beschrieben.

PostgreSQL-Instanz erstellen

Console

  1. Rufen Sie in der Google Cloud Console die Seite Cloud SQL-Instanzen auf.

    Zur Seite "Cloud SQL-Instanzen"

  2. Klicken Sie auf Instanz erstellen.

  3. Klicken Sie auf PostgreSQL auswählen.

  4. Geben Sie im Feld Instanz-ID einen Namen für die Instanz ein (INSTANCE_NAME).

  5. Geben Sie im Feld Passwort ein Passwort für den Postgres-Nutzer ein.

  6. Übernehmen Sie für die anderen Felder die Standardwerte.

  7. Klicken Sie auf Instanz erstellen.

gcloud

  • Erstellen Sie die PostgreSQL-Instanz:

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

    Ersetzen Sie Folgendes:

    Es dauert einige Minuten, bis die Instanz erstellt und einsatzbereit ist.

Datenbank erstellen

Console

  1. Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

    Zur Seite "Cloud SQL-Instanzen"

  2. Wählen Sie die Instanz INSTANCE_NAME aus.

  3. Wechseln Sie zum Tab Datenbanken.

  4. Klicken Sie auf Datenbank erstellen.

  5. Geben Sie im Dialogfeld Datenbankname DATABASE_NAME ein.

  6. Klicken Sie auf Erstellen.

gcloud

  • Erstellen Sie die Datenbank in der kürzlich erstellten Instanz:

    gcloud sql databases create DATABASE_NAME \
    --instance INSTANCE_NAME

    Ersetzen Sie DATABASE_NAME durch einen Namen für die Datenbank in der Instanz.

Nutzer erstellen

Generieren Sie ein zufälliges Passwort für den Datenbanknutzer und schreiben Sie es in eine Datei mit dem Namen dbpassword:

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

Console

  1. Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

    Zur Seite "Cloud SQL-Instanzen"

  2. Wählen Sie die Instanz INSTANCE_NAME aus.

  3. Öffnen Sie den Tab Nutzer.

  4. Klicken Sie auf Nutzerkonto hinzufügen.

  5. Im Dialogfeld Integrierte Authentifizierung:

    1. Geben Sie den Nutzernamen DATABASE_USERNAME ein.
    2. Geben Sie den Inhalt der Datei dbpassword als Passwort PASSWORD ein.

  6. Klicken Sie auf Add (Hinzufügen).

gcloud

  • Erstellen Sie den Nutzer in der kürzlich erstellten Instanz und legen Sie sein Passwort als Inhalt von dbpassword fest:

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

    Ersetzen Sie DATABASE_USERNAME durch einen Namen für den Nutzer in der Instanz.

Cloud Storage-Bucket einrichten

Sie können statische Inhalte und von Nutzern hochgeladene Medien in Rails mit hoher Verfügbarkeit im Objektspeicher hosten.

Console

  1. In the Google Cloud console, go to the Cloud Storage Buckets page.

    Go to Buckets page

  2. Click Create bucket.
  3. On the Create a bucket page, enter your bucket information. To go to the next step, click Continue.
    • For Name your bucket, enter a name that meets the bucket naming requirements.
    • For Location, select the following: us-central1
    • For Choose a default storage class for your data, select the following: Standard.
    • For Choose how to control access to objects, select an Access control option.
    • For Advanced settings (optional), specify an encryption method, a retention policy, or bucket labels.
  4. Click Create.

gcloud

Das gsutil-Befehlszeilentool wurde im Rahmen der Installation der gcloud CLI installiert.

  • Cloud Storage-Bucket erstellen Verwenden Sie zum Erstellen eines eindeutigen Cloud Storage-Bucket-Namens PROJECT_ID und das Suffix Ihrer Wahl MEDIA_BUCKET_SUFFIX. In Cloud Storage müssen Bucket-Namen global eindeutig sein.

    gsutil mb -l REGION gs://PROJECT_ID-MEDIA_BUCKET_SUFFIX

Ändern Sie nach dem Erstellen eines Buckets die Berechtigungen von Bildobjekten so, dass sie für alle lesbar sind.

Console

  1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

    Buckets aufrufen

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, den Sie veröffentlichen möchten.

  3. Wählen Sie oben auf der Seite den Tab Berechtigungen aus.

  4. Klicken Sie auf die Schaltfläche Mitglieder hinzufügen.

    Das Dialogfeld Mitglieder hinzufügen wird angezeigt.

  5. Geben Sie im Feld Neue Mitglieder den Wert allUsers ein.

  6. Wählen Sie im Drop-down-Menü Rolle auswählen das Untermenü Cloud Storage aus und klicken Sie auf die Option Storage-Objektbetrachter.

  7. Klicken Sie auf Speichern.

Sobald das Objekt öffentlich freigegeben ist, wird in der Spalte für den öffentlichen Zugriff ein Link-Symbol angezeigt. Wenn Sie auf dieses Symbol klicken, erhalten Sie die URL für das Objekt.

Wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Ruby-Vorgängen in der Google Cloud Console abrufen, erfahren Sie unter Fehlerbehebung.

gcloud

  • Verwenden Sie den Befehl gsutil iam ch, um alle Objekte öffentlich zu machen. Verwenden Sie den Wert für MEDIA_BUCKET_SUFFIX, den Sie beim Erstellen des Buckets verwendet haben.

    gsutil iam ch allUsers:objectViewer gs://PROJECT_ID-MEDIA_BUCKET_SUFFIX

Secret-Werte im Secret Manager speichern

Nachdem die Sicherungsdienste konfiguriert sind, benötigt Rails sichere Informationen wie Passwörter, um auf diese Dienste zugreifen zu können. Anstatt diese Werte direkt in den Rails-Quellcode einzufügen, werden in dieser Anleitung Rails-Anmeldedaten und Secret Manager verwendet, um diese Informationen sicher zu speichern.

Datei mit verschlüsselten Anmeldedaten und Speicherschlüssel als Secret Manager-Secret erstellen

Rails speichert Secrets in einer verschlüsselten Datei mit dem Namen "config/credentials.yml.enc". Die Datei kann mit dem lokalen config/master.key oder der Umgebungsvariablen ENV[“RAILS_MASTER_KEY”] entschlüsselt werden. In der Datei mit den Anmeldedaten können Sie das Datenbankpasswort der Cloud SQL-Instanz und andere Zugriffsschlüssel für externe APIs speichern.

Sie können diesen Schlüssel sicher im Secret Manager speichern. Anschließend können Sie Cloud Run und Cloud Build Zugriff auf den Schlüssel gewähren, indem Sie Zugriff auf die entsprechenden Dienstkonten gewähren. Dienstkonten werden durch eine E-Mail-Adresse identifiziert, die die Projektnummer enthält.

  1. Generieren Sie die Datei config/credentials.yml.enc mit dem folgenden Befehl:

    bin/rails credentials:edit

    Der Befehl erstellt einen config/master.key, wenn kein Masterschlüssel definiert ist, und eine config/credentials.yml.enc-Datei, wenn die Datei nicht vorhanden ist. Dadurch wird eine temporäre Datei in Ihrer Standard-$EDITOR mit den entschlüsselten Inhalten für die hinzuzufügenden Secrets geöffnet.

  2. Kopieren Sie das neu erstellte Passwort für die PostgreSQL-Instanzdatenbank aus der Datei dbpassword und fügen Sie es in die Datei mit den Anmeldedaten ein:

    secret_key_base: GENERATED_VALUE
gcp:
  db_password: PASSWORD

    Secrets können mit Rails.application.credentials aufgerufen werden. Beispiel: Rails.application.credentials.secret_key_base sollte die Basis des geheimen Schlüssels der Anwendung zurückgeben und Rails.application.credentials.gcp[:db_passsword] Ihr Datenbankpasswort zurückgeben.

  3. Die config/credentials/yml.enc wird verschlüsselt, config/master.key kann jedoch in Secret Manager gespeichert werden.

    Console

    1. Rufen Sie in der Google Cloud Console die Seite Secret Manager auf.

      Zur Seite „Secret Manager“

    2. Klicken Sie auf Secret erstellen.

    3. Geben Sie im Feld Name einen Namen für das RAILS_SECRET_NAME-Secret ein.

    4. Fügen Sie im Dialogfeld Secret-Wert den Wert "mater.key" in das Feld ein.

    5. Klicken Sie auf Secret erstellen.

    6. Notieren Sie sich die Projektnummer auf der Seite Secret-Detailseite Ihres Secrets:

      projects/PROJECTNUM/secrets/RAILS_SECRET_NAME

    7. Klicken Sie im Tab Berechtigungen auf Mitglied hinzufügen.

    8. Geben Sie in das Feld Neue Mitglieder PROJECTNUM-compute@developer.gserviceaccount.com ein und drücken Sie dann Enter.

    9. Geben Sie in das Feld Neue Mitglieder PROJECTNUM@cloudbuild.gserviceaccount.com ein und drücken Sie dann Enter.

    10. Wählen Sie im Drop-down-Menü Rolle die Option Secret Manager Secret Accessor aus.

    11. Klicken Sie auf Speichern.

    gcloud

    1. Erstellen Sie ein neues Secret mit dem Wert von config/master.key:

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

      Geben Sie für RAILS_SECRET_NAME einen Namen für das neue Secret an.

    2. Prüfen Sie Folgendes, um die Erstellung des Secrets zu bestätigen:

      gcloud secrets describe RAILS_SECRET_NAME

gcloud secrets versions access latest --secret RAILS_SECRET_NAME

    3. Rufen Sie den Wert der Projektnummer ab:

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

    4. Gewähren Sie Zugriff auf das Secret für das Cloud Run-Dienstkonto:

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

      Ersetzen Sie PROJECTNUM durch den obigen Wert für die Projektnummer.

    5. Gewähren Sie dem Cloud Build-Dienstkonto Zugriff auf das Secret:

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

      Achten Sie in der Ausgabe darauf, dass bindings die beiden Dienstkonten als Mitglieder auflistet.

Rails-Anwendung mit Produktionsdatenbank und Speicher verbinden

In dieser Anleitung wird eine PostgreSQL-Instanz als Produktionsdatenbank und Cloud Storage als Speicher-Back-End verwendet. Damit Rails eine Verbindung zum neu erstellten Datenbank- und Storage-Bucket herstellen kann, müssen Sie in der Datei .env alle Informationen angeben, die für den Zugriff erforderlich sind. Die Datei .env enthält die Konfiguration für die Umgebungsvariablen der Anwendung. Die Anwendung liest diese Datei mit dem dotenv-Gem. Da die Secrets in credentials.yml.enc und Secret Manager gespeichert sind, muss .env nicht verschlüsselt werden, da es keine vertraulichen Anmeldedaten enthält.

  1. Konfigurieren Sie die Datei .env, um die Rails-Anwendung für die Verbindung zu der Datenbank und dem Storage-Bucket zu konfigurieren.

  2. Ändern Sie die Konfiguration der Datei .env so: Verwenden Sie den Wert von MEDIA_BUCKET_SUFFIX, den Sie beim Erstellen des Buckets verwendet haben.

    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

    Die Rails-Anwendung ist jetzt für die Verwendung von Cloud SQL und Cloud Storage bei der Bereitstellung in Cloud Run eingerichtet.

Cloud Build Zugriff auf Cloud SQL gewähren

Damit Cloud Build die Datenbankmigrationen anwenden kann, müssen Sie Berechtigungen für Cloud Build erteilen, um auf Cloud SQL zugreifen zu können.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Identitäts- und Zugriffsverwaltung auf.

    Zur Seite „Identitäts- und Zugriffsverwaltung“

  2. Klicken Sie auf Mitglied bearbeiten, um den Eintrag für das Mitglied PROJECTNUM@cloudbuild.gserviceaccount.com zu bearbeiten.

  3. Klicken Sie auf Weitere Rolle hinzufügen.

  4. Wählen Sie im Dialogfeld Rolle auswählen die Option Cloud SQL-Client aus.

  5. Klicken Sie auf Speichern.

gcloud

  • Gewähren Sie Cloud Build die Berechtigung, auf Cloud SQL zuzugreifen:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/cloudsql.client

App in Cloud Run bereitstellen

Da die Sicherungsdienste nun eingerichtet sind, können Sie die Anwendung jetzt als Cloud Run-Dienst bereitstellen.

  1. Verwenden Sie die bereitgestellte Datei cloudbuild.yaml, um mithilfe von Cloud Build das Image zu erstellen, die Datenbankmigrationen auszuführen und die statischen Assets zu füllen:

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

    Ersetzen Sie SERVICE_NAME durch den Namen des Service. Dieser erste Build-Vorgang kann einige Minuten dauern. Wenn das Zeitlimit des Builds überschritten wird, erhöhen Sie das Zeitlimit, indem Sie --timeout=2000s in den obigen Build-Befehl einfügen.

  2. Wenn der Build erfolgreich ist, stellen Sie den Cloud Run-Dienst zum ersten Mal bereit. Legen Sie die Dienstregion, das Basis-Image und die verbundene Cloud SQL-Instanz fest:

    gcloud run deploy SERVICE_NAME \
     --platform managed \
     --region REGION \
     --image gcr.io/PROJECT_ID/SERVICE_NAME \
     --add-cloudsql-instances PROJECT_ID:REGION:INSTANCE_NAME \
     --allow-unauthenticated

    Aus der angezeigten Ausgabe sollte hervorgehen, dass die Bereitstellung erfolgreich war, und es sollte eine Dienst-URL ausgegeben werden:

    Service [SERVICE_NAME] revision [SERVICE_NAME-00001-tug] has been deployed
 and is serving 100 percent of traffic at https://SERVICE_NAME-HASH-uc.a.run.app

  3. Rufen Sie die Dienst-URL auf, um sich den bereitgestellten Dienst anzeigen zu lassen.

    Screenshot der Landingpage der Katzenalbum-Anwendung.
    Wenn die Dienst-URL Cat Fotoalbum anzeigt, befinden Sie sich auf der Startseite der Anwendung.

  4. Versuchen Sie, ein neues Foto hochzuladen. Wenn das Foto erfolgreich hochgeladen wurde, wurde die Rails-Anwendung erfolgreich bereitgestellt.

    Screenshot der Landingpage der Katzenalbum-Anwendung mit einem Foto.

Anwendung aktualisieren

Die ersten Schritte zum Bereitstellen waren zwar komplex, aber die Aktualisierung ist einfacher:

  1. Führen Sie das Build- und Migrationsskript von Cloud Build aus:

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

  2. Stellen Sie den Dienst bereit und geben Sie dabei nur die Region und das Image an:

    gcloud run deploy SERVICE_NAME \
     --platform managed \
     --region REGION \
     --image gcr.io/PROJECT_ID/SERVICE_NAME

Code verstehen

Die Rails-Beispiel-App wurde mit Standard-Rails-Befehlen erstellt. Die folgenden Befehle erstellen die Anwendung "cat_Album" und generieren mit dem Gerüstbefehl ein Modell, einen Controller und Ansichten für die Fotoressource:

rails new cat_album
rails generate scaffold Photo caption:text

Datenbankverbindung

Die Datei config/database.yml enthält die Konfiguration, die für den Zugriff auf Ihre Datenbanken in verschiedenen Umgebungen (Entwicklung, Test, Produktion) erforderlich ist. Die Produktionsdatenbank ist beispielsweise so konfiguriert, dass sie in Cloud SQL for PostgreSQL ausgeführt wird. Der Datenbankname und der Nutzername werden über Umgebungsvariablen in der Datei .env festgelegt, während das Datenbankpasswort in der Datei config/credentials.yml.enc gespeichert wird. Hierfür muss RAILS_MASTER_KEY entschlüsselt werden.

Wenn die App in Cloud Run ausgeführt wird (vollständig verwaltet), stellt sie eine Verbindung zur PostgreSQL-Instanz über einen Socket her, der von der Cloud Run-Umgebung bereitgestellt wird. Wenn die Anwendung auf dem lokalen Computer ausgeführt wird, stellt sie über den Cloud SQL Auth-Proxy eine Verbindung zur PostgreSQL-Instanz her.

run/rails/config/database.yml 
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"] %>"

In der Cloud gespeicherte Medien, die von Nutzern hochgeladen wurden

Rails verwendet Active Storage, um Dateien bei Cloud Storage-Anbietern hochzuladen. Die Dateien config/storage.yml und config/environments/production.rb geben Cloud Storage als Dienstanbieter in der Produktionsumgebung an.

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

Automatisierung mit Cloud Build

Die cloudbuild.yaml-Datei führt nicht nur die typischen Image-Build-Schritte aus, mit denen das Container-Image erstellt und in die Container Registry übertragen wird, sondern auch die Rails-Datenbankmigrationen. Diese benötigen Zugriff auf die Datenbank. Erreicht wird dies mit app-engine-exec-wrapper, einer Hilfefunktion für Cloud SQL Proxy.

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

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

  - id: "apply migrations"
    name: "gcr.io/google-appengine/exec-wrapper"
    entrypoint: "bash"
    args:
      [
        "-c",
        "/buildstep/execute.sh -i gcr.io/${PROJECT_ID}/${_SERVICE_NAME} -s ${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME} -e RAILS_MASTER_KEY=$$RAILS_KEY -- bundle exec rails db:migrate"
      ]
    secretEnv: ["RAILS_KEY"]

substitutions:
  _REGION: us-central1
  _SERVICE_NAME: rails-cat-album
  _INSTANCE_NAME: cat-album
  _SECRET_NAME: rails-master-key

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

images:
  - "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}"

In dieser Konfiguration werden Substitutionsvariablen verwendet. Wenn Sie die Werte direkt in der Datei ändern, kann das Flag --substitutions zum Zeitpunkt der Migration weggelassen werden.

In dieser Konfiguration werden nur vorhandene Migrationen im Verzeichnis db/migrate angewendet. Informationen zum Erstellen von Migrationsdateien finden Sie unter Active Record Migrations (Aktive Eintragsmigrationen).

Zum Erstellen des Images und Anwenden von Migrationen benötigt die Cloud Build-Konfiguration Zugriff auf das Secret RAILS_MASTER_KEY von Secret Manager. Im Feld availableSecrets werden die Secret-Version und die Umgebungsvariablen festgelegt, die für das Secret verwendet werden sollen. Das Masterschlüssel-Secret wird im Schritt des Build-Images als Argument übergeben und dann beim Erstellen des Images als RAILS_MASTER_KEY im Dockerfile festgelegt.

run/rails/Dockerfile 
ARG MASTER_KEY
ENV RAILS_MASTER_KEY=${MASTER_KEY}

Wenn Sie die Cloud Build-Konfiguration erweitern möchten, um die Bereitstellung in eine einzige Konfiguration aufzunehmen, ohne zwei Befehle ausführen zu müssen, finden Sie weitere Informationen unter Kontinuierliche Bereitstellung aus Git mit Cloud Build. Dies erfordert die beschriebenen IAM-Änderungen.

Unterstützung für Ruby 2.7

Obwohl in dieser Anleitung Ruby 3.0 verwendet wird, wird auch Ruby 2.7 unterstützt. Für die Verwendung von Ruby 2.7 ändern Sie das Ruby-Basis-Image im Dockerfile in 2.7.

run/rails/Dockerfile 
# Pinning the OS to buster because the nodejs install script is buster-specific.
# Be sure to update the nodejs install command if the base image OS is updated.
FROM ruby:3.0-buster

Clean-up

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.