Migrer des applications Node.js de Heroku vers Cloud Run

Last reviewed 2023-10-01 UTC

Ce tutoriel explique comment migrer des applications Web Node.js exécutées sur Heroku vers Cloud Run sur Google Cloud. Il est destiné aux architectes et aux propriétaires de produits qui souhaitent migrer leurs applications de Heroku vers des services gérés sur Google Cloud.

Cloud Run est une plate-forme de calcul gérée qui vous permet d'exécuter des conteneurs sans état pouvant être appelés via des requêtes HTTP. Il repose sur une instance Knative Open Source, qui rend possible la portabilité entre différentes plates-formes et prend en charge des normes et des workflows de conteneurs pour la livraison continue. La plate-forme Cloud Run est bien intégrée à la suite de produits Google Cloud, et facilite la conception et le développement d'applications portables, évolutives et résilientes.

Dans ce tutoriel, vous allez apprendre à migrer vers Google Cloud une application écrite dans Node.js et qui utilise Heroku Postgres comme service de sauvegarde sur Heroku. L'application Web, qui est placée dans un conteneur et hébergée dans Cloud Run, utilise Cloud SQL pour PostgreSQL en tant que couche de persistance.

Dans ce tutoriel, vous utilisez une application simple appelée "Tasks" qui vous permet d'afficher et de créer des tâches. Ces dernières sont stockées dans Heroku Postgres dans le déploiement actuel de l'application sur Heroku.

Dans ce tutoriel, nous partons du principe que vous maîtrisez les fonctionnalités de base de Heroku et que vous possédez un compte Heroku (ou que vous y avez accès). Nous partons également du principe que vous connaissez bien Cloud Run, Cloud SQL, Docker et Node.js.

Objectifs

  • Créer une image Docker pour déployer l'application sur Cloud Run
  • Créer une instance Cloud SQL pour PostgreSQL qui servira de backend après la migration vers Google Cloud
  • Examiner le code Node.js pour comprendre comment Cloud Run se connecte à Cloud SQL et pour voir les modifications qui doivent être apportées au code (le cas échéant) afin d'effectuer la migration de Heroku vers Cloud Run
  • Migrer les données de Heroku Postgres vers Cloud SQL pour PostgreSQL
  • Déployer l'application sur Cloud Run
  • Tester l'application déployée

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Les ressources que vous utilisez sur Heroku peuvent également vous être facturées.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  4. Activer les API Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access.

    Activer les API

  5. Assurez-vous que vous disposez du ou des rôles suivants au niveau du projet : Cloud Run > Cloud Run Admin, Cloud Storage > Storage Admin, Cloud SQL > Cloud SQL Admin, Compute Engine > Compute Network Admin, Resource Manager > Project IAM Admin, Cloud Build > Cloud Build Editor, Serverless VPC Access > Serverless VPC Access Admin, Logging > Logs Viewer, Service Accounts > Service Account Admin, Service Accounts > Service Account User, and Service Usage > Service Usage Consumer

    Vérifier les rôles

    1. Dans la console Google Cloud, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.

    3. Dans la colonne Compte principal, recherchez la ligne qui contient votre adresse e-mail.

      Si votre adresse e-mail ne figure pas dans cette colonne, cela signifie que vous n'avez aucun rôle.

    4. Dans la colonne Rôle de la ligne contenant votre adresse e-mail, vérifiez si la liste des rôles inclut les rôles requis.

    Attribuer les rôles

    1. Dans la console Google Cloud, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.
    3. Cliquez sur Accorder l'accès.
    4. Dans le champ Nouveaux comptes principaux, saisissez votre adresse e-mail.
    5. Dans la liste Sélectinoner un rôle, sélectionnez un rôle.
    6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
    7. Cliquez sur Enregistrer.

  6. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  7. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  8. Activer les API Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access.

    Activer les API

  9. Assurez-vous que vous disposez du ou des rôles suivants au niveau du projet : Cloud Run > Cloud Run Admin, Cloud Storage > Storage Admin, Cloud SQL > Cloud SQL Admin, Compute Engine > Compute Network Admin, Resource Manager > Project IAM Admin, Cloud Build > Cloud Build Editor, Serverless VPC Access > Serverless VPC Access Admin, Logging > Logs Viewer, Service Accounts > Service Account Admin, Service Accounts > Service Account User, and Service Usage > Service Usage Consumer

    Vérifier les rôles

    1. Dans la console Google Cloud, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.

    3. Dans la colonne Compte principal, recherchez la ligne qui contient votre adresse e-mail.

      Si votre adresse e-mail ne figure pas dans cette colonne, cela signifie que vous n'avez aucun rôle.

    4. Dans la colonne Rôle de la ligne contenant votre adresse e-mail, vérifiez si la liste des rôles inclut les rôles requis.

    Attribuer les rôles

    1. Dans la console Google Cloud, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.
    3. Cliquez sur Accorder l'accès.
    4. Dans le champ Nouveaux comptes principaux, saisissez votre adresse e-mail.
    5. Dans la liste Sélectinoner un rôle, sélectionnez un rôle.
    6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
    7. Cliquez sur Enregistrer.

Configurer votre environnement

  1. Ouvrez Cloud Shell.

    Ouvrir Cloud Shell

  2. Dans Cloud Shell, définissez les variables d'environnement et les valeurs par défaut de Google Cloud CLI utilisée dans ce tutoriel.

    gcloud config set project PROJECT_ID
gcloud config set run/region us-central1

    Remplacez PROJECT_ID par l'ID du projet.

Architecture

Les figures suivantes décrivent l'architecture de l'application Web sur Heroku (en l'état) et son agencement architectural sur Google Cloud (que vous allez créer).

Architecture en l'état sur Heroku.
Figure 1. Architecture en l'état sur Heroku.

L'application Tasks actuellement déployée sur Heroku comprend un ou plusieurs dynos Web. Les dynos Web sont capables de recevoir du trafic HTTP et d'y répondre, contrairement aux dynos de nœud de calcul, qui conviennent mieux aux tâches en arrière-plan et aux tâches temporisées. L'application diffuse une page d'index qui affiche les tâches stockées dans une base de données Postgres, à l'aide de la bibliothèque de modèles Mustache pour Node.js.

Vous pouvez accéder à l'application via une URL HTTPS. Une route /tasks au niveau de cette URL vous permet de créer des tâches.

Architecture en l'état sur Heroku.
Figure 2. Architecture que vous créez sur Google Cloud

Sur Google Cloud, Cloud Run est utilisé comme plate-forme sans serveur pour déployer l'application Tasks. Cloud Run est conçu pour exécuter des conteneurs sans état et basés sur des requêtes. Il convient parfaitement lorsque votre service géré doit prendre en charge des applications en conteneur dotées d'une fonctionnalité d'autoscaling, mais également de scaling à zéro instance lorsqu'elles ne diffusent pas de trafic.

Mettre en correspondance les composants utilisés dans Heroku et Google Cloud

Le tableau suivant met en correspondance les composants de la plate-forme Heroku et ceux de Google Cloud. Cela vous aide à traduire l'architecture décrite dans ce tutoriel de Heroku vers Google Cloud.

Composant Plate-forme Heroku Google Cloud
Conteneurs Dynos : Heroku utilise le modèle de conteneur pour créer des applications Heroku et procéder à leur scaling. Ces conteneurs Linux sont appelés dynos et peuvent effectuer un scaling jusqu'à un nombre d'instances que vous spécifiez afin de répondre aux exigences de ressources de votre application Heroku. Vous pouvez choisir parmi un éventail de types de dynos en fonction des exigences en termes de processeur et de mémoire de votre application. Conteneurs Cloud Run : Google Cloud accepte l'exécution de charges de travail placées dans des conteneurs sans état, qui peuvent être exécutés dans un environnement entièrement géré ou dans des clusters Google Kubernetes Engine (GKE).
Application Web Application Heroku : les dynos sont les principaux composants des applications Heroku. Les applications sont en général composées d'un ou de plusieurs types de dynos. Il s'agit habituellement d'une combinaison de dynos Web et de nœud de calcul. Service Cloud Run : une application Web peut être modélisée comme un service Cloud Run. Chaque service obtient son propre point de terminaison HTTPS et peut automatiquement passer de 0 à N instances ou inversement en fonction du trafic sur le point de terminaison du service.
Base de données Heroku Postgres est la base de données en tant que service (DaaS) reposant sur PostgreSQL d'Heroku. Cloud SQL est un service de base de données géré pour les bases de données relationnelles sur Google Cloud.

Déployer l'exemple d'application Web Tasks sur Heroku

Les sections suivantes montrent comment configurer l'interface de ligne de commande (CLI) pour Heroku, cloner le dépôt source GitHub et déployer l'application sur Heroku.

Configurer l'interface de ligne de commande pour Heroku

Ce tutoriel exécute la CLI Heroku dans Cloud Shell et doit s'authentifier à l'aide d'une clé API Heroku. Lors de l'exécution dans Cloud Shell, la CLI Heroku ne peut pas s'authentifier à l'aide d'un mot de passe ni d'une authentification Web.

Si vous exécutez l'exemple sur un terminal local, vous pouvez également utiliser n'importe quelle méthode d'authentification de la CLI Heroku. Lorsque vous exécutez le tutoriel sur un terminal local, vous devez également installer Google Cloud CLI, git et Docker.

  1. Connectez-vous à la console Web pour Heroku, puis copiez la valeur de votre clé API depuis la page des paramètres de votre compte.

  2. Dans Cloud Shell, installez la CLI Heroku.

  3. Dans Cloud Shell, installez la CLI Heroku. Lorsque vous y êtes invité, saisissez la valeur de la clé API que vous avez copiée depuis la console Heroku, et non le mot de passe que vous utilisez pour vous connecter à la console.

    heroku login --interactive

Cloner le dépôt source

  1. Dans Cloud Shell, clonez le dépôt GitHub de l'exemple d'application Tasks :

    git clone https://github.com/GoogleCloudPlatform/migrate-webapp-heroku-to-cloudrun-node.git

  2. Remplacez les répertoires par le répertoire créé en clonant le dépôt :

    cd migrate-webapp-heroku-to-cloudrun-node

    Le répertoire contient les fichiers suivants :

    • Un script Node.js nommé index.js comportant le code des routes diffusées par l'application Web.
    • Les fichiers package.json et package-lock.json décrivant les dépendances de l'application Web. Vous devez installer ces dépendances pour que l'application s'exécute.
    • Un fichier Procfile qui spécifie la commande que l'application exécute au démarrage. Vous créez un fichier Procfile pour déployer votre application sur Heroku.
    • Un répertoire views qui comporte le contenu HTML diffusé par l'application Web sur la route "/".
    • Un fichier .gitignore.

Déployer une application sur Heroku

  1. Dans Cloud Shell, créez une application Heroku :

    heroku create

    Notez le nom créé pour l'application. Vous aurez besoin de cette valeur à l'étape suivante.

  2. Créez une variable d'environnement pour le nom de l'application Heroku :

    export APP_NAME=APP_NAME

    Remplacez APP_NAME par le nom d'application renvoyé par la commande heroku create.

  3. Ajoutez le module complémentaire Heroku Postgres pour provisionner une base de données PostgreSQL :

    heroku addons:create heroku-postgresql:mini

  4. Assurez-vous que le module complémentaire a bien été ajouté :

    heroku addons

    Si le module complémentaire Postgres a bien été ajouté, un message de ce type apparaît :

    Add-on               Plan     Price       State
-----------------    -----    --------    -----
heroku-postgresql    mini     5$/month    created

  5. Déployez l'application sur Heroku :

    git push heroku master

  6. Exécutez la commande suivante pour confirmer la valeur de DATABASE_URL.

    heroku config

    Notez la valeur récupérée de DATABASE_URL. Vous aurez besoin de cette valeur à l'étape suivante.

  7. Exécutez un conteneur Docker.

    docker run -it --rm postgres psql "DATABASE_URL"

    Remplacez DATABASE_URL par l'URL Heroku Postgres que vous avez noté à l'étape précédente.

  8. Dans le conteneur Docker, créez la table TASKS à l'aide de la commande suivante :

    CREATE TABLE TASKS
(DESCRIPTION TEXT NOT NULL);

  9. Quittez le conteneur :

    exit

  10. Dans Cloud Shell, obtenez l'URL Web de votre application Heroku en exécutant la commande suivante :

    heroku info

  11. Ouvrez l'URL dans une fenêtre de navigateur. L'application ressemble à la capture d'écran suivante (bien qu'aucune tâche ne soit répertoriée dans votre version) :

    Application de liste de tâches dans le navigateur Web.

  12. Créez des exemples de tâches dans votre application à partir du navigateur. Assurez-vous que les tâches sont récupérées à partir de la base de données et visibles dans l'interface utilisateur.

Préparer le code de l'application Web pour la migration vers Cloud Run

Cette section détaille les étapes à suivre pour préparer votre application Web en vue de son déploiement sur Cloud Run.

Créer et publier votre conteneur Docker dans Container Registry

Vous avez besoin d'une image Docker pour créer le conteneur d'applications afin qu'il puisse s'exécuter dans Cloud Run. Vous pouvez créer le conteneur manuellement ou à l'aide de Buildpacks.

Créer le conteneur manuellement

  1. Dans Cloud Shell, créez un fichier Dockerfile dans le répertoire créé en clonant le dépôt de ce tutoriel :

    cat <<"EOF" > Dockerfile
# Use the official Node image.
# https://hub.docker.com/_/node
FROM node:10-alpine

# Create and change to the app directory.
WORKDIR /app

# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./
RUN npm install

# Copy local code to the container image.
COPY . /app

# Configure and document the service HTTP port.
ENV PORT 8080
EXPOSE $PORT

# Run the web service on container startup.
CMD ["npm", "start"]
EOF

  2. Créez votre conteneur avec Cloud Build, puis publiez l'image dans Container Registry :

    gcloud builds submit --tag gcr.io/PROJECT_ID/APP_NAME:1 \
  --gcs-log-dir=gs://PROJECT_ID_cloudbuild

  3. Créez une variable d'environnement destinée à contenir le nom de l'image Docker que vous avez créée :

    export IMAGE_NAME="gcr.io/PROJECT_ID/APP_NAME:1"

Créer un conteneur avec Buildpacks

  1. Dans Cloud Shell, installez la CLI pack.

  2. Configurez la CLI pack de sorte qu'elle utilise l'outil de création Heroku par défaut :

    pack config default-builder heroku/buildpacks:22

  3. Créez une variable d'environnement destinée à contenir le nom de l'image Docker :

    export IMAGE_NAME=gcr.io/PROJECT_ID/APP_NAME:1

  4. Créez l'image à l'aide de la commande pack, puis transférez-la ou publiez-la dans Container Registry :

    pack build --publish $IMAGE_NAME

Créer une instance Cloud SQL pour PostgreSQL

Créez une instance Cloud SQL pour PostgreSQL qui servira de backend pour l'application Web. Dans ce tutoriel, PostgreSQL est le mieux adapté comme exemple d'application déployé sur Heroku, car celui-ci se sert d'une base de données Postgres comme backend. Pour les besoins de cette application, la migration vers Cloud SQL pour PostgreSQL à partir d'un service Postgres géré ne nécessite aucune modification du schéma.

  1. Préparez votre réseau pour Cloud SQL avec une adresse IP privée.

    gcloud compute addresses create google-managed-services-default \
  --global \
  --purpose=VPC_PEERING \
  --prefix-length=16 \
  --description="peering range for CloudSQL Private Service Access" \
  --network=default

gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --ranges=google-managed-services-default \
  --network=default \
  --project=PROJECT_ID

  2. Créez une variable d'environnement nommée CLOUDSQL_DB_NAME et destinée à contenir le nom de l'instance de base de données que vous allez créer à l'étape suivante :

    export CLOUDSQL_DB_NAME=tasks-db

  3. Créez la base de données :

    gcloud sql instances create $CLOUDSQL_DB_NAME \
--cpu=1 \
--memory=4352Mib \
--database-version=POSTGRES_15 \
--region=us-central1 \
--network default \
--no-assign-ip

    L'initialisation de l'instance peut prendre quelques minutes.

  4. Définissez le mot de passe de l'utilisateur Postgres :

    gcloud sql users set-password postgres \
    --instance=$CLOUDSQL_DB_NAME  \
    --password=POSTGRES_PASSWORD

    Remplacez POSTGRES_PASSWORD par le mot de passe que vous souhaitez utiliser pour la base de données Postgres.

Importer des données dans Cloud SQL à partir de Heroku Postgres

Vous disposez de plusieurs modèles de migration pour migrer des données vers Cloud SQL. En règle générale, la meilleure approche, qui nécessite peu ou pas de temps d'arrêt, consiste à configurer Cloud SQL en tant qu'instance dupliquée de la base de données en cours de migration, et à faire de Cloud SQL l'instance principale après la migration. Heroku Postgres ne prend pas en charge les instances dupliquées externes (suiveurs). Dans ce tutoriel, vous migrez le schéma de l'application à l'aide d'outils Open Source.

Dans le cadre de l'application Tasks de ce tutoriel, vous vous servez de l'utilitaire pg_dump pour exporter des données de Heroku Postgres vers un bucket Cloud Storage, puis les importer dans Cloud SQL. Cet utilitaire peut transférer des données entre des versions homogènes ou lorsque la version de la base de données de destination est plus récente que celle de la base de données source.

  1. Dans Cloud Shell, obtenez les identifiants de la base de données Heroku Postgres associée à l'exemple d'application. Vous en aurez besoin à l'étape suivante.

    heroku pg:credentials:url

    Cette commande affiche la chaîne d'informations de connexion et l'URL de connexion de votre application. La chaîne d'informations de connexion respecte le format suivant :

    "dbname=DATABASE_NAME host=FQDN port=5432 user=USER_NAME password=PASSWORD_STRING sslmode=require"

    Vous aurez besoin des valeurs affichées dans la chaîne de connexion à l'étape suivante.

    Pour obtenir un exemple de valeur FQDN (nom de domaine complet) dans une chaîne d'informations de connexion, consultez la documentation Heroku.

  2. Définissez les variables d'environnement de sorte qu'elles contiennent les valeurs Heroku que vous utiliserez aux étapes suivantes :

    export HEROKU_PG_DBNAME=DATABASE_NAME
export HEROKU_PG_HOST=FQDN
export HEROKU_PG_USER=USER_NAME
export HEROKU_PG_PASSWORD=PASSWORD_STRING

    Remplacez les éléments suivants :

    • DATABASE_NAME : nom de base de données affiché dans la chaîne d'informations.
    • FQDN : nom de domaine complet affiché dans la chaîne d'informations.
    • USER_NAME : nom d'utilisateur affiché dans la chaîne d'informations.
    • PASSWORD_STRING : chaîne de mot de passe affichée dans la chaîne d'informations.

  3. Créez une sauvegarde au format SQL de votre base de données Heroku Postgres :

    docker run \
  -it --rm \
  -e PGPASSWORD=$HEROKU_PG_PASSWORD \
  -v $(pwd):/tmp \
  --entrypoint "pg_dump" \
  postgres \
  -Fp \
  --no-acl \
  --no-owner \
  -h $HEROKU_PG_HOST \
  -U $HEROKU_PG_USER \
  $HEROKU_PG_DBNAME > herokudump.sql

  4. Créez une variable d'environnement destinée à contenir le nom de votre bucket Cloud Storage :

    export PG_BACKUP_BUCKET=gs://PROJECT_ID-pg-backup-bucket

  5. Créez un bucket Cloud Storage :

    gcloud storage buckets create $PG_BACKUP_BUCKET \
  --location=us-central1 \
  --public-access-prevention \
  --uniform-bucket-level-access

  6. Importez le fichier SQL dans ce bucket :

    gcloud storage cp herokudump.sql $PG_BACKUP_BUCKET/herokudump.sql

  7. Attribuez à votre instance Cloud SQL avec les rôles nécessaires pour importer le fichier SQL à partir du bucket Cloud Storage :

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='get("serviceAccountEmailAddress")') \
  --role=roles/storage.objectAdmin

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='get("serviceAccountEmailAddress")') \
  --role=roles/cloudsql.editor

  8. Importez le fichier SQL dans l'instance Cloud SQL :

    gcloud sql import sql $CLOUDSQL_DB_NAME $PG_BACKUP_BUCKET/herokudump.sql \
  --database=postgres \
  --user=postgres

    Lorsque l'invite do you want to continue (y/n) s'affiche, saisissez "y".

Méthode d'accès de Cloud Run à la base de données Cloud SQL

De la même façon que l'application Web déployée sur Heroku doit se connecter à l'instance gérée de Heroku Postgres, Cloud Run doit avoir accès à Cloud SQL pour pouvoir lire et écrire des données.

Cloud Run communique avec Cloud SQL à l'aide du proxy Cloud SQL activé et configuré automatiquement lorsque vous déployez le conteneur sur Cloud Run. La base de données n'a pas besoin d'adresses IP externes approuvées, car toutes les communications qu'elle reçoit proviennent du proxy utilisant un protocole TCP sécurisé.

Votre code doit appeler des opérations de base de données (telles que l'extraction de données de la base de données ou l'écriture dans celle-ci) en appelant le proxy via un socket UNIX.

Étant donné que cette application Web est écrite dans Node.js, vous utilisez la bibliothèque pg-connection-string pour analyser une URL de base de données et créer un objet config. L'avantage de cette approche est qu'elle facilite la connexion à la base de données backend sur Heroku et Cloud Run.

À l'étape suivante, vous transmettez l'URL de la base de données en tant que variable d'environnement lors du déploiement de l'application Web.

Déployer l'exemple d'application sur Cloud Run

  1. Dans Cloud Shell, configurez l'accès au VPC sans serveur pour autoriser le trafic privé de Cloud Run vers Cloud SQL :

    gcloud compute networks subnets create serverless-connector-subnet \
--network=default \
--range=10.0.0.0/28 \
--region=us-central1

gcloud compute networks vpc-access connectors create serverless-connector \
--region=us-central1 \
--subnet=serverless-connector-subnet

  2. Dans Cloud Shell, créez une variable d'environnement contenant le nom de connexion de l'instance Cloud SQL créée :

    export DB_CONN_NAME=$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='value(connectionName)')

  3. Créez une variable d'environnement nommée DATABASE_URL et destinée à contenir la chaîne de connexion permettant de se connecter au proxy Cloud SQL via un port UNIX.

    export DATABASE_URL="socket:/cloudsql/${DB_CONN_NAME}?db=postgres&user=postgres&password=POSTGRES_PASSWORD"

  4. Créez un compte de service pour Cloud Run avec un rôle IAM pour vous connecter à la base de données :

    gcloud iam service-accounts create sa-run-db-client

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:sa-run-db-client@PROJECT_ID.iam.gserviceaccount.com \
    --role=roles/cloudsql.client

  5. Déployez l'application Web sur Cloud Run :

    gcloud run deploy tasksapp-PROJECT_ID \
    --image=$IMAGE_NAME \
    --service-account=sa-run-db-client@PROJECT_ID.iam.gserviceaccount.com \
    --set-env-vars=DATABASE_URL=$DATABASE_URL \
    --add-cloudsql-instances $DB_CONN_NAME \
    --vpc-connector serverless-connector \
    --allow-unauthenticated

    La commande précédente associe également votre conteneur Cloud Run à l'instance de base de données Cloud SQL que vous avez créée. La commande définit une variable d'environnement pour Cloud Run afin qu'elle pointe vers la chaîne DATABASE_URL que vous avez créée à l'étape précédente.

Tester l'application

  1. Dans Cloud Shell, obtenez l'URL à laquelle Cloud Run diffuse le trafic :

    gcloud run services list

    Vous pouvez également examiner le service Cloud Run dans la console Google Cloud.

  2. Assurez-vous que votre application Web accepte les requêtes HTTP en accédant à l'URL du service Cloud Run.

Cloud Run crée ou lance un conteneur lorsqu'une requête HTTP est envoyée au point de terminaison de diffusion et si un conteneur n'est pas déjà en cours d'exécution. Cela signifie que la diffusion de la requête qui entraîne le lancement d'un nouveau conteneur risque de prendre un peu plus de temps. Étant donné ce temps supplémentaire, tenez compte du nombre de requêtes simultanées que votre application peut prendre en charge et de ses exigences spécifiques en matière de mémoire.

Pour cette application, vous utilisez les paramètres de simultanéité par défaut, qui permettent à un service Cloud Run de diffuser 80 requêtes simultanément à partir d'un même conteneur.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, procédez comme suit : Vous pouvez également supprimer les ressources créées dans Heroku pour ce tutoriel.

Supprimer le projet Google Cloud

  1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer l'application Heroku

Pour supprimer l'exemple d'application que vous avez déployé sur Heroku et le module complémentaire PostgreSQL associé, exécutez la commande suivante :

heroku apps:destroy -a APP_NAME

Étape suivante