Tutoriel sur l'authentification des utilisateurs finaux pour Cloud Run

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce tutoriel explique comment créer un service de vote composé des éléments suivants :

  • Un client basé sur un navigateur qui :

    1. Utilise Identity Platform pour récupérer un jeton d'ID.
    2. Permet aux utilisateurs de voter pour leur animal de compagnie favori.
    3. Ajoute ce jeton d'ID à une requête adressée au serveur Cloud Run qui traite le vote.
  • Un serveur Cloud Run qui :

    1. Vérifie que l'utilisateur final s'est correctement authentifié en fournissant un jeton d'ID valide.
    2. Traite le vote de l'utilisateur final.
    3. À l'aide de ses propres identifiants, envoie le vote à Cloud SQL pour stockage.
  • Une base de données PostgresSQL qui stocke les votes.

Par souci de simplicité, ce tutoriel utilise Google en tant que fournisseur : les utilisateurs doivent s'authentifier à l'aide d'un compte Google pour acquérir leur jeton d'ID. Toutefois, vous pouvez faire appel à d'autres fournisseurs ou méthodes d'authentification pour la connexion des utilisateurs.

Ce service réduit les risques de sécurité à l'aide de l'outil Secret Manager pour protéger les données sensibles utilisées pour la connexion à l'instance Cloud SQL. Il utilise également une identité de service appliquant le principe de moindre privilège pour sécuriser l'accès à la base de données.

Objectifs

Écrire, compiler et déployer dans Cloud Run un service qui montre comment :

  • Utiliser Identity Platform pour authentifier un utilisateur final auprès du backend du service Cloud Run.

  • Créer une identité bénéficiant du moindre privilège pour le service afin d'accorder un accès minimal aux ressources Google Cloud.

  • Utiliser Secret Manager pour gérer les données sensibles lors de la connexion du service Cloud Run à une base de données PostgreSQL.

Coûts

Ce tutoriel utilise 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.

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. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

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

  5. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  6. Activer les API Cloud Run, Secret Manager, Cloud SQL, Container Registry, and Cloud Build .

    Activer les API

Configurer les valeurs par défaut pour gcloud

Pour configurer gcloud avec les valeurs par défaut pour votre service Cloud Run, procédez comme suit :

  1. Définissez le projet par défaut :

    gcloud config set project PROJECT_ID

    Remplacez PROJECT_ID par le nom du projet que vous avez créé pour ce tutoriel.

  2. Configurez gcloud pour la région choisie :

    gcloud config set run/region REGION

    Remplacez REGION par la région Cloud Run compatible de votre choix.

Emplacements Cloud Run

Cloud Run est régional, ce qui signifie que l'infrastructure qui exécute vos services Cloud Run est située dans une région spécifique et gérée par Google pour être disponible de manière redondante dans toutes les zones de cette région.

Lors de la sélection de la région dans laquelle exécuter vos services Cloud Run, vous devez tout d'abord considérer vos exigences en matière de latence, de disponibilité et de durabilité. Vous pouvez généralement sélectionner la région la plus proche de vos utilisateurs, mais vous devez tenir compte de l'emplacement des autres produits Google Cloud utilisés par votre service Cloud Run. L'utilisation conjointe de produits Google Cloud dans plusieurs emplacements peut avoir une incidence sur la latence et le coût de votre service.

Cloud Run est disponible dans les régions suivantes :

Soumis aux tarifs de niveau 1

Soumis aux tarifs de niveau 2

  • asia-east2 (Hong Kong)
  • asia-northeast3 (Séoul, Corée du Sud)
  • asia-southeast1 (Singapour)
  • asia-southeast2 (Jakarta)
  • asia-south1 (Mumbai, Inde)
  • asia-south2 (Delhi, Inde)
  • australia-southeast1 (Sydney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsovie, Pologne)
  • europe-west2 (Londres, Royaume-Uni)
  • europe-west3 (Francfort, Allemagne)
  • europe-west6 (Zurich, Suisse) Icône Feuille Faibles émissions de CO2
  • northamerica-northeast1 (Montréal) Icône Feuille Faibles émissions de CO2
  • northamerica-northeast2 (Toronto) Icône Feuille Faibles émissions de CO2
  • southamerica-east1 (São Paulo, Brésil) Icône Feuille Faibles émissions de CO2
  • southamerica-west1 (Santiago, Chili)
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Si vous avez déjà créé un service Cloud Run, vous pouvez afficher la région dans le tableau de bord Cloud Run de la console Google Cloud.

Récupérer l'exemple de code

Pour récupérer l’exemple de code à utiliser, procédez comme suit :

  1. Clonez le dépôt de l'exemple d'application sur votre machine locale :

    Node.js

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Python

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Java

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

  2. Accédez au répertoire contenant l'exemple de code Cloud Run :

    Node.js

    cd nodejs-docs-samples/run/idp-sql/

    Python

    cd python-docs-samples/run/idp-sql/

    Java

    cd java-docs-samples/run/idp-sql/

Visualiser l'architecture

Schéma de l'architecture
Ce schéma illustre la connexion d'un utilisateur final via une fenêtre pop-up Google Sign-in émis par le fournisseur d'identité, suivie d'une redirection vers Cloud Run avec l'identité de l'utilisateur.
  1. Un utilisateur final envoie la première requête au serveur Cloud Run.

  2. Le client se charge dans le navigateur.

  3. L'utilisateur fournit les identifiants de connexion via la fenêtre pop-up Google Sign-in à partir d'Identity Platform. Une alerte souhaite la bienvenue à l'utilisateur connecté.

  4. Le contrôle est redirigé vers le serveur. L'utilisateur final vote à l'aide du client, qui récupère un jeton d'ID depuis Identity Platform et l'ajoute à l'en-tête de la requête de vote.

  5. Lorsque le serveur reçoit la requête, il vérifie le jeton d'ID Identity Platform, ce qui confirme que l'utilisateur final est correctement authentifié. Le serveur envoie ensuite le vote à Cloud SQL à l'aide de ses propres identifiants.

Comprendre le code principal

L'exemple est mis en œuvre avec un client et un serveur, comme décrit ci-dessous.

Intégrer Identity Platform : code côté client

Cet exemple utilise les SDK Firebase pour s'intégrer à Identity Platform visant afin de gérer la connexion et les utilisateurs. Pour se connecter à Identity Platform, le code JavaScript côté client stocke la référence aux identifiants du projet en tant qu'objet de configuration et importe les SDK Firebase JavaScript requis :

const config = {
  apiKey: 'API_KEY',
  authDomain: 'PROJECT_ID.firebaseapp.com',
};
<!-- Firebase App (the core Firebase SDK) is always required and must be listed first-->
<script src="https://www.gstatic.com/firebasejs/7.18/firebase-app.js"></script>
<!-- Add Firebase Auth service-->
<script src="https://www.gstatic.com/firebasejs/7.18/firebase-auth.js"></script>

Le SDK Firebase JavaScript gère le flux de connexion en invitant l'utilisateur final à se connecter à son compte Google via une fenêtre pop-up. Il le redirige ensuite vers le service.

function signIn() {
  const provider = new firebase.auth.GoogleAuthProvider();
  provider.addScope('https://www.googleapis.com/auth/userinfo.email');
  firebase
    .auth()
    .signInWithPopup(provider)
    .then(result => {
      // Returns the signed in user along with the provider's credential
      console.log(`${result.user.displayName} logged in.`);
      window.alert(`Welcome ${result.user.displayName}!`);
    })
    .catch(err => {
      console.log(`Error during sign in: ${err.message}`);
      window.alert('Sign in failed. Retry or check your browser logs.');
    });
}

Lorsqu'un utilisateur s'est connecté avec succès, le client utilise les méthodes Firebase pour générer un jeton d'ID. Le client ajoute le jeton d'ID à l'en-tête Authorization de sa requête au serveur.

async function vote(team) {
  if (firebase.auth().currentUser) {
    // Retrieve JWT to identify the user to the Identity Platform service.
    // Returns the current token if it has not expired. Otherwise, this will
    // refresh the token and return a new one.
    try {
      const token = await firebase.auth().currentUser.getIdToken();
      const response = await fetch('/', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          Authorization: `Bearer ${token}`,
        },
        body: 'team=' + team, // send application data (vote)
      });
      if (response.ok) {
        const text = await response.text();
        window.alert(text);
        window.location.reload();
      }
    } catch (err) {
      console.log(`Error when submitting vote: ${err}`);
      window.alert('Something went wrong... Please try again!');
    }
  } else {
    window.alert('User not signed in.');
  }
}

Intégrer Identity Platform : code côté serveur

Le serveur vérifie le jeton d'ID utilisateur envoyé par le client à l'aide du SDK Admin Firebase. Si le jeton d'ID fourni présente le bon format, qu'il n'a pas expiré et qu'il est correctement signé, la méthode renvoie le jeton d'ID décodé. Le serveur extrait l'uid Identity Platform pour cet utilisateur.

Node.js

const firebase = require('firebase-admin');
// Initialize Firebase Admin SDK
firebase.initializeApp();

// Extract and verify Id Token from header
const authenticateJWT = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (authHeader) {
    const token = authHeader.split(' ')[1];
    // If the provided ID token has the correct format, is not expired, and is
    // properly signed, the method returns the decoded ID token
    firebase
      .auth()
      .verifyIdToken(token)
      .then(decodedToken => {
        const uid = decodedToken.uid;
        req.uid = uid;
        next();
      })
      .catch(err => {
        req.logger.error(`Error with authentication: ${err}`);
        return res.sendStatus(403);
      });
  } else {
    return res.sendStatus(401);
  }
};

Python

def jwt_authenticated(func: Callable[..., int]) -> Callable[..., int]:
    @wraps(func)
    def decorated_function(*args: a, **kwargs: a) -> a:
        header = request.headers.get("Authorization", None)
        if header:
            token = header.split(" ")[1]
            try:
                decoded_token = firebase_admin.auth.verify_id_token(token)
            except Exception as e:
                logger.exception(e)
                return Response(status=403, response=f"Error with authentication: {e}")
        else:
            return Response(status=401)

        request.uid = decoded_token["uid"]
        return func(*args, **kwargs)

    return decorated_function

Java

/** Extract and verify Id Token from header */
private String authenticateJwt(Map<String, String> headers) {
  String authHeader =
      (headers.get("authorization") != null)
          ? headers.get("authorization")
          : headers.get("Authorization");
  if (authHeader != null) {
    String idToken = authHeader.split(" ")[1];
    // If the provided ID token has the correct format, is not expired, and is
    // properly signed, the method returns the decoded ID token
    try {
      FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
      String uid = decodedToken.getUid();
      return uid;
    } catch (FirebaseAuthException e) {
      logger.error("Error with authentication: " + e.toString());
      throw new ResponseStatusException(HttpStatus.FORBIDDEN, "", e);
    }
  } else {
    logger.error("Error no authorization header");
    throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
  }
}

Connecter le serveur à Cloud SQL

Le service se connecte au socket de domaine Unix de l'instance Cloud SQL au format /cloudsql/CLOUD_SQL_CONNECTION_NAME.

Node.js

/**
 * Connect to the Cloud SQL instance through UNIX Sockets
 *
 * @param {object} credConfig The Cloud SQL connection configuration from Secret Manager
 * @returns {object} Knex's PostgreSQL client
 */
const connectWithUnixSockets = async credConfig => {
  const dbSocketPath = process.env.DB_SOCKET_PATH || '/cloudsql';
  // Establish a connection to the database
  return Knex({
    client: 'pg',
    connection: {
      user: credConfig.DB_USER, // e.g. 'my-user'
      password: credConfig.DB_PASSWORD, // e.g. 'my-user-password'
      database: credConfig.DB_NAME, // e.g. 'my-database'
      host: `${dbSocketPath}/${credConfig.CLOUD_SQL_CONNECTION_NAME}`,
    },
    ...config,
  });
};

Python

def init_unix_connection_engine(
    db_config: Dict[str, str]
) -> sqlalchemy.engine.base.Engine:
    creds = credentials.get_cred_config()
    db_user = creds["DB_USER"]
    db_pass = creds["DB_PASSWORD"]
    db_name = creds["DB_NAME"]
    db_socket_dir = creds.get("DB_SOCKET_DIR", "/cloudsql")
    cloud_sql_connection_name = creds["CLOUD_SQL_CONNECTION_NAME"]

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # postgres+pg8000://<db_user>:<db_pass>@/<db_name>
        #                         ?unix_sock=<socket_path>/<cloud_sql_instance_name>/.s.PGSQL.5432
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,  # e.g. "my-database-user"
            password=db_pass,  # e.g. "my-database-password"
            database=db_name,  # e.g. "my-database-name"
            query={
                "unix_sock": "{}/{}/.s.PGSQL.5432".format(
                    db_socket_dir, cloud_sql_connection_name  # e.g. "/cloudsql"
                )  # i.e "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
            },
        ),
        **db_config,
    )
    pool.dialect.description_encoding = None
    logger.info("Database engine initialised from unix conection")

    return pool

Java

Utilisez l'intégration Spring Cloud Google PostgreSQL pour interagir avec vos bases de données PostgreSQL dans Google Cloud SQL à l'aide de bibliothèques Spring JDBC. Définissez votre configuration Cloud SQL pour MySQL afin de configurer automatiquement un bean DataSource, qui, associé à Spring JDBC, fournit un objet bean JdbcTemplate. qui permet d'effectuer des opérations telles que l'interrogation et la modification d'une base de données.

# Uncomment and add env vars for local development
# spring.datasource.username=${DB_USER}
# spring.datasource.password=${DB_PASSWORD}
# spring.cloud.gcp.sql.database-name=${DB_NAME}
# spring.cloud.gcp.sql.instance-connection-name=${CLOUD_SQL_CONNECTION_NAME}  
private final JdbcTemplate jdbcTemplate;

public VoteController(JdbcTemplate jdbcTemplate) {
  this.jdbcTemplate = jdbcTemplate;
}

Gérer une configuration sensible avec Secret Manager

Secret Manager permet le stockage centralisé et sécurisé de données sensibles, telles qu'une configuration de Cloud SQL. Le service injecte des identifiants Cloud SQL à partir de Secret Manager au moment de l'exécution par l'intermédiaire d'une variable d'environnement. En savoir plus sur l'utilisation des secrets avec Cloud Run.

Node.js

// CLOUD_SQL_CREDENTIALS_SECRET is the resource ID of the secret, passed in by environment variable.
// Format: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION
const {CLOUD_SQL_CREDENTIALS_SECRET} = process.env;
if (CLOUD_SQL_CREDENTIALS_SECRET) {
  try {
    // Parse the secret that has been added as a JSON string
    // to retrieve database credentials
    return JSON.parse(CLOUD_SQL_CREDENTIALS_SECRET.toString('utf8'));
  } catch (err) {
    throw Error(
      `Unable to parse secret from Secret Manager. Make sure that the secret is JSON formatted: ${err}`
    );
  }
}

Python

def get_cred_config() -> Dict[str, str]:
    secret = os.environ.get("CLOUD_SQL_CREDENTIALS_SECRET")
    if secret:
        return json.loads(secret)

Java

/** Retrieve config from Secret Manager */
public static HashMap<String, Object> getConfig() {
  String secret = System.getenv("CLOUD_SQL_CREDENTIALS_SECRET");
  if (secret == null) {
    throw new IllegalStateException("\"CLOUD_SQL_CREDENTIALS_SECRET\" is required.");
  }
  try {
    HashMap<String, Object> config = new Gson().fromJson(secret, HashMap.class);
    return config;
  } catch (JsonSyntaxException e) {
    logger.error(
        "Unable to parse secret from Secret Manager. Make sure that it is JSON formatted: "
            + e);
    throw new RuntimeException(
        "Unable to parse secret from Secret Manager. Make sure that it is JSON formatted.");
  }
}

Configurer Identity Platform

Identity Platform nécessite d'être configuré manuellement dans la console Google Cloud.

  1. Accédez à la page Identity Platform Marketplace dans la console Google Cloud.

    Accéder à la page Identity Platform Marketplace

  2. Cliquez sur Activer Identity Platform. Cela crée un ID client OAuth2 nommé Web client (auto created by Google Service).

  3. Téléchargez l'ID OAuth2 généré :

    1. Dans une nouvelle fenêtre, accédez à la page "API et services > Identifiants".

      Accéder à la page API et services > Identifiants.

    2. Dans l'enregistrement pour "Client Web (créé automatiquement par le service Google)", cliquez sur l'icône de téléchargement.

    3. Notez client_id et client_secret.

  4. Configurez Google en tant que fournisseur :

    1. Accédez à la page "Fournisseurs d'identité" dans Cloud Console.

      Accéder à la page "Fournisseurs d'identité"

    2. Cliquez sur Ajouter un fournisseur.

    3. Dans la liste, sélectionnez Google.

    4. Dans les paramètres de configuration du SDK Web, saisissez les valeurs obtenues précédemment :

      1. ID client Web : client_id

      2. Code secret du client Web : client_secret

    5. Cliquez sur Configurer l'écran.

      1. Comme type d'utilisateur, choisissez Externe.

      2. Renseignez les champs obligatoires (adresse e-mail d'assistance, adresse e-mail du développeur).

      3. Continuez jusqu'à la page Récapitulatif.

    6. Sous "Configurer votre application", cliquez sur Informations sur la configuration. Copiez l'extrait de code dans le fichier static/config.js de l'exemple afin d'initialiser le SDK client Identity Platform. Vous pouvez également localiser l'extrait de code sur la page Google Cloud Console, dans la section Informations sur la configuration de l'application, puis le copier dans le fichier static/config.js de l'exemple.

    7. Cliquez sur Enregistrer.

Déployer le service

Suivez les étapes ci-dessous pour terminer le provisionnement et le déploiement de l'infrastructure, ou automatisez le processus dans Cloud Shell en cliquant sur "Exécuter sur Google Cloud" :

Exécuter sur Google Cloud

  1. Créez une instance Cloud SQL comportant une base de données PostgreSQL à l'aide de la console ou de la CLI :

    gcloud sql instances create CLOUD_SQL_INSTANCE_NAME \
        --database-version=POSTGRES_12 \
        --region=CLOUD_SQL_REGION \
        --cpu=2 \
        --memory=7680MB \
        --root-password=DB_PASSWORD
  2. Ajoutez vos identifiants Cloud SQL au fichier postgres-secrets.json :

    Node.js

    {
      "CLOUD_SQL_CONNECTION_NAME": "PROJECT_ID:REGION:INSTANCE",
      "DB_NAME": "postgres",
      "DB_USER": "postgres",
      "DB_PASSWORD": "PASSWORD_SECRET"
    }
    

    Python

    {
      "CLOUD_SQL_CONNECTION_NAME": "PROJECT_ID:REGION:INSTANCE",
      "DB_NAME": "postgres",
      "DB_USER": "postgres",
      "DB_PASSWORD": "PASSWORD_SECRET"
    }
    

    Java

    {
      "spring.cloud.gcp.sql.instance-connection-name": "PROJECT_ID:REGION:INSTANCE",
      "spring.cloud.gcp.sql.database-name": "postgres",
      "spring.datasource.username": "postgres",
      "spring.datasource.password": "PASSWORD_SECRET"
    }

  3. Créez un secret avec versions gérées à l'aide de la console ou de la CLI :

    gcloud secrets create idp-sql-secrets \
        --replication-policy="automatic" \
        --data-file=postgres-secrets.json
  4. Créez un compte de service pour le serveur à l'aide de la console ou de la CLI :

    gcloud iam service-accounts create idp-sql-identity
  5. Attribuez des rôles pour l'accès à Secret Manager et à Cloud SQL à l'aide de la console ou de la CLI :

    1. Autorisez le compte de service associé au serveur à accéder au secret créé :

      gcloud secrets add-iam-policy-binding idp-sql-secrets \
        --member serviceAccount:idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
        --role roles/secretmanager.secretAccessor
    2. Autorisez le compte de service associé au serveur à accéder à Cloud SQL :

      gcloud projects add-iam-policy-binding PROJECT_ID \
        --member serviceAccount:idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
        --role roles/cloudsql.client
  6. Générez l'image de conteneur à l'aide de Cloud Build :

    Node.js

    gcloud builds submit --tag gcr.io/PROJECT_ID/idp-sql

    Python

    gcloud builds submit --tag gcr.io/PROJECT_ID/idp-sql

    Java

    Cet exemple utilise Jib pour créer des images Docker à l'aide d'outils Java courants. Jib optimise les builds de conteneurs sans requérir de fichier Dockerfile ni d'installation Docker. Découvrez comment créer des conteneurs Java avec Jib.

    1. Utilisez l'assistant d'identification gcloud pour autoriser Docker à transférer du contenu vers votre registre de conteneurs.

      gcloud auth configure-docker

    2. Utilisez le plug-in Maven Jib pour créer et transférer le conteneur dans Container Registry.

      mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/idp-sql

  7. Déployez l'image de conteneur dans Cloud Run à l'aide de la console ou de la CLI. Notez que le serveur est déployé pour autoriser l'accès non authentifié. Ainsi, l'utilisateur peut charger le client et lancer le processus. Le serveur vérifie manuellement le jeton d'ID ajouté à la requête de vote, en authentifiant l'utilisateur final.

    gcloud run deploy idp-sql \
        --image gcr.io/PROJECT_ID/idp-sql \
        --allow-unauthenticated \
        --service-account idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
        --add-cloudsql-instances PROJECT_ID:REGION:CLOUD_SQL_INSTANCE_NAME \
        --update-secrets CLOUD_SQL_CREDENTIALS_SECRET=idp-sql-secrets:latest

    Notez également les options --service-account, --add-cloudsql-instances et --update-secrets, qui spécifient respectivement l'identité du service, la connexion à l'instance Cloud SQL et le nom du secret avec la version en tant que variable d'environnement.

Touches finales

Identity Platform nécessite que vous autorisiez l'URL du service Cloud Run en tant que redirection autorisée après la connexion de l'utilisateur :

  1. Modifiez le fournisseur Google en cliquant sur l'icône Stylo de la page Fournisseurs d'identité.

  2. Dans le panneau de droite, sous "Domaines autorisés", cliquez sur Ajouter un domaine, puis saisissez l'URL du service Cloud Run.

    Vous pouvez trouver l'URL du service dans les journaux une fois que la compilation ou le déploiement ont eu lieu. Vous pouvez également la trouver à tout moment à l'aide de la commande suivante :

    gcloud run services describe idp-sql --format 'value(status.url)'

Essayez-le !

Pour tester le service complet :

  1. Accédez dans votre navigateur à l'URL fournie par l'étape de déploiement ci-dessus.

  2. Cliquez sur le bouton Se connecter avec Google et suivez la procédure d'authentification.

  3. Enregistrez votre vote.

    Elle doit se présenter comme ceci :

    Capture d&#39;écran de l&#39;interface utilisateur qui indique le nombre de votes pour chaque équipe, ainsi qu&#39;une liste de votes.

Si vous décidez de poursuivre le développement de ces services, n'oubliez pas qu'ils ont un accès IAM restreint au reste de Google Cloud. Des rôles IAM supplémentaires devront donc leur être attribués afin de pouvoir accéder à de nombreux autres services.

Nettoyer

Si vous avez créé un projet pour ce tutoriel, supprimez-le. Si vous avez utilisé un projet existant et que vous souhaitez le conserver sans les modifications du présent tutoriel, supprimez les ressources créées pour ce tutoriel.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  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 les ressources du tutoriel

  1. Supprimez le service Cloud Run que vous avez déployé dans ce tutoriel :

    gcloud run services delete SERVICE-NAME

    SERVICE-NAME est le nom de service que vous avez choisi.

    Vous pouvez également supprimer des services Cloud Run à partir de Google Cloud Console.

  2. Supprimez la configuration régionale gcloud par défaut que vous avez ajoutée lors de la configuration du tutoriel :

     gcloud config unset run/region
    
  3. Supprimez la configuration du projet :

     gcloud config unset project
    
  4. Supprimez les autres ressources Google Cloud créées dans ce tutoriel :

Étape suivante