Tutoriel sur l'authentification des utilisateurs finaux pour Cloud Run

Ce tutoriel explique comment créer sur Cloud Run une application Web dont l'accès est limité aux utilisateurs connectés et dont les données sont stockées dans PostgreSQL. L'intégration d'Identity Platform gère l'authentification des utilisateurs finaux et fournit des jetons d'ID utilisateur afin d'autoriser le service à interroger une base de données Cloud SQL. Ce service comporte un client public qui permet aux utilisateurs externes de se connecter et d'accéder à une interface de vote.

Par souci de simplicité, ce tutoriel utilise Google en tant que fournisseur : les utilisateurs doivent se connecter à l'aide d'un compte Google. 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é en faisant appel à l'outil Secret Manager afin de protéger les données sensibles utilisées pour la connexion à l'instance Cloud SQL, et en appliquant le principe de moindre privilège à l'identité de service.

L'authentification d'un utilisateur final dans le cadre de cet exemple implique les événements suivants :

  1. Le client demande à Identity Platform de fournir un jeton d'ID signé pour l'utilisateur.
  2. Le jeton d'ID signé est envoyé avec des requêtes à un serveur.
  3. Le serveur vérifie l'identité de l'utilisateur à l'aide de ce jeton d'ID signé et accorde l'accès à la base de données Cloud SQL PostgreSQL.

Ce tutoriel n'illustre pas l'utilisation de la méthode d'authentification suivante :

  • L'authentification IAM, qui utilise des rôles IAM pour vérifier et valider automatiquement les identités. Cette solution est recommandée pour l'authentification de service à service, et non pour les identités individuelles. Pour en savoir plus sur l'authentification de service à service, consultez le Tutoriel sur la sécurisation des services Cloud Run. À l'heure actuelle, il n'est pas possible de combiner les méthodes d'authentification basées sur IAM et sur les jetons d'ID.

Objectifs

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

    • authentifier les utilisateurs finaux pour l'accès au service Cloud Run à l'aide d'Identity Platform ;

    • connecter un service Cloud Run à une base de données PostgreSQL à l'aide de Secret Manager afin de gérer des données sensibles ;

  • créer une identité de service bénéficiant du moindre privilège pour un accès minimal aux ressources Google Cloud.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Vous devriez pouvoir réaliser l'intégralité de ce projet avec les crédits de l'essai gratuit.

Les nouveaux utilisateurs de Cloud Platform 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 que la facturation est activée pour votre 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 que la facturation est activée pour votre projet.

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

    Activer les API

  7. Installez et initialisez le SDK Cloud.

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)
  • southamerica-east1 (São Paulo, Brésil) Icône Feuille Faibles émissions de CO2
  • 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 Cloud Console.

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 utilisateur via un 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 envoie sa première requête au service.

  2. Le service Cloud Run fournit au client un formulaire de connexion utilisateur.

  3. L'utilisateur se connecte via la fenêtre pop-up Google Sign-in, qui utilise Identity Platform.

  4. Le flux d'authentification redirige l'utilisateur, avec son identité, vers le service Cloud Run.

  5. Lorsque l'utilisateur vote, le client émet un jeton d'identification et l'ajoute aux requêtes du serveur. Le serveur vérifie le jeton d'ID et accorde l'accès en écriture à Cloud SQL.

Comprendre le code

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 les utilisateurs à se connecter à leur compte Google par le biais d'une fenêtre pop-up, puis en les redirigeant 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, les méthodes Firebase génèrent des jetons d'ID permettant d'identifier l'utilisateur de manière unique et de lui accorder l'accès. Le client communique avec le serveur en ajoutant l'en-tête Authorization qui contient le jeton d'ID.

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 utilise le SDK Firebase Admin pour l'intégration d'Identity Platform et la validation de l'identité de l'utilisateur à partir du jeton d'ID utilisateur transmis par le client. 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é requis pour extraire l'uid Identity Platform correspondant à 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: Any, **kwargs: Any) -> Any:
        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);
  }
}

Se connecter à 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.");
  }
}

Transmettre le service

Configurer Identity Platform

Identity Platform nécessite d'être configuré manuellement dans Cloud Console.

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

    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. Dans le résultat JSON téléchargé, notez les valeurs 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 "Configuration du SDK Web", saisissez les valeurs du fichier JSON que vous avez téléchargé 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.

    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 à l'aide de la console ou de la CLI :

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

    1. Autorisez le compte de service à 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 à 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 :

    gcloud beta 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

    Plus précisément, cette commande fait appel aux options --service-account, --add-cloudsql-instances et --update-secrets pour spécifier 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

Autorisez 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. 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 Cloud Console, 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