Migrer des applications Node.js de Heroku vers Cloud Run

---

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 :

• Cloud Run
• Cloud Storage
• Cloud SQL for PostgreSQL
• Container Registry

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. Enable the Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs.

   Enable the APIs

5. Make sure that you have the following role or roles on the project: 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

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Accéder à IAM
   2. Sélectionnez le projet.
   3. Cliquez sur Accorder l'accès.

   4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

   5. Dans la liste Sélectionner 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.

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

      Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

      Go to project selector

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

   10. Enable the Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs.

       Enable the APIs

   11. Make sure that you have the following role or roles on the project: 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

       Check for the roles

       1. In the Google Cloud console, go to the IAM page.

          Go to IAM
       2. Select the project.

       3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

       4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

       Grant the roles

       1. In the Google Cloud console, go to the IAM page.

          Accéder à IAM
       2. Sélectionnez le projet.
       3. Cliquez sur Accorder l'accès.

       4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

       5. Dans la liste Sélectionner 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).

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.

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) :

    

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.

Remarque : La migration de bases de données depuis des environnements sur site ou hébergés vers Google Cloud est un processus en plusieurs étapes qui nécessite une planification minutieuse, la migration du schéma et des données, ainsi que la réalisation de tests. Pour en savoir plus, consultez la Documentation Cloud Run et la page Importer des données dans Cloud SQL.

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.

   Remarque : Comme cet exemple d'application Tasks est une application Web publique et utilise l'option --allow-unauthenticated, le déploiement échouera si votre organisation applique le rôle Règle d'administration iam.allowedPolicyMemberDomains. Pour déployer un exemple d'application Cloud Run public et non authentifié, désactivez la règle sur votre projet de tutoriel. Pour une application réelle nécessitant une authentification pour les utilisateurs finaux, consultez la section Authentifier les utilisateurs finaux.

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

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :
• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.
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.

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

• Apprenez-en plus sur l'importation de données dans Cloud SQL.
• Explorez la documentation Cloud Run.