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 ressources que vous utilisez sur Heroku peuvent également vous être facturées.
Avant de commencer
- 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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs.
-
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
-
In the Google Cloud console, go to the IAM page.
Go to IAM - Select the project.
-
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.
- 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
-
In the Google Cloud console, go to the IAM page.
Accéder à IAM - Sélectionnez le projet.
- Cliquez sur Accorder l'accès.
-
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.
- Dans la liste Sélectionner un rôle, sélectionnez un rôle.
- Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
- Cliquez sur Enregistrer.
-
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs.
-
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
-
In the Google Cloud console, go to the IAM page.
Go to IAM - Select the project.
-
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.
- 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
-
In the Google Cloud console, go to the IAM page.
Accéder à IAM - Sélectionnez le projet.
- Cliquez sur Accorder l'accès.
-
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.
- Dans la liste Sélectionner un rôle, sélectionnez un rôle.
- Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
- Cliquez sur Enregistrer.
-
Configurer votre environnement
Ouvrez Cloud Shell.
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).
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.
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.
Connectez-vous à la console Web pour Heroku, puis copiez la valeur de votre clé API depuis la page des paramètres de votre compte.
Dans Cloud Shell, installez la CLI Heroku.
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
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
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
etpackage-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 fichierProcfile
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
.
- Un script Node.js nommé
Déployer une application sur Heroku
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.
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 commandeheroku create
.Ajoutez le module complémentaire Heroku Postgres pour provisionner une base de données PostgreSQL :
heroku addons:create heroku-postgresql:mini
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
Déployez l'application sur Heroku :
git push heroku master
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.
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.Dans le conteneur Docker, créez la table
TASKS
à l'aide de la commande suivante :CREATE TABLE TASKS (DESCRIPTION TEXT NOT NULL);
Quittez le conteneur :
exit
Dans Cloud Shell, obtenez l'URL Web de votre application Heroku en exécutant la commande suivante :
heroku info
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) :
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
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
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
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
Dans Cloud Shell, installez la CLI pack.
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
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
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.
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
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
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.
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.
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.
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.
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
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
Créez un bucket Cloud Storage :
gcloud storage buckets create $PG_BACKUP_BUCKET \ --location=us-central1 \ --public-access-prevention \ --uniform-bucket-level-access
Importez le fichier SQL dans ce bucket :
gcloud storage cp herokudump.sql $PG_BACKUP_BUCKET/herokudump.sql
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
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
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
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)')
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"
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
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
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.
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
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- 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.