Tutoriel sur l'authentification des utilisateurs finaux pour Cloud Run

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

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

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

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.

    Go to project selector

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

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

    Go to project selector

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

  6. Enable the Cloud Run, Secret Manager, Cloud SQL, Artifact Registry, and Cloud Build APIs.

    Enable the APIs

Rôles requis

Pour obtenir les autorisations nécessaires pour suivre le tutoriel, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

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

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 émise par Identity Platform, 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 ses identifiants de connexion via la boîte de dialogue de connexion Google à 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]:
    """Use the Firebase Admin SDK to parse Authorization header to verify the
    user ID token.

    The server extracts the Identity Platform uid for that user.
    """

    @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, int]
) -> sqlalchemy.engine.base.Engine:
    """Initializes a Unix socket connection pool for a Cloud SQL instance of PostgreSQL.

    Args:
        db_config: a dictionary with connection pool config

    Returns:
        A SQLAlchemy Engine instance.
    """
    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": f"{db_socket_dir}/{cloud_sql_connection_name}/.s.PGSQL.5432"
                # e.g. "/cloudsql", "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
            },
        ),
        **db_config,
    )
    pool.dialect.description_encoding = None
    logger.info("Database engine initialized from unix connection")

    return pool

Java

Utilisez l'intégration Spring Cloud Google PostgreSQL pour interagir avec vos bases de données PostgreSQL dans 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]:
    """Retrieve Cloud SQL credentials stored in Secret Manager
    or default to environment variables.

    Returns:
        A dictionary with Cloud SQL credential values
    """
    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.

  3. Créez l'écran d'autorisation OAuth :

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

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

    2. Sélectionnez la page Écran d'autorisation OAuth.

    3. À des fins de test, sélectionnez Externe.

    4. Cliquez sur Créer.

    5. Dans la boîte de dialogue Informations sur l'application,

      1. Indiquez le nom de l'application.
      2. Sélectionnez l'un des e-mails d'assistance utilisateur affichés.
      3. Saisissez l'adresse e-mail que vous souhaitez utiliser pour contacter le développeur.

    6. Cliquez sur Enregistrer et continuer.

    7. Dans la boîte de dialogue Champs d'application, cliquez sur Enregistrer et continuer.

    8. Dans la boîte de dialogue Test users (Utilisateurs de test), cliquez sur Save and Continue (Enregistrer et continuer).

    9. Dans la boîte de dialogue Résumé, cliquez sur Retour au tableau de bord.

    10. Sous État de la publication, cliquez sur Publier l'application.

    11. Cliquez sur Confirmer.

  4. Créez et obtenez votre ID client et votre code secret OAuth :

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

    2. En haut de la page, cliquez sur Créer des identifiants, puis sélectionnez OAuth client ID.

    3. Dans Type d'application, sélectionnez Application Web et indiquez le nom.

    4. Cliquez sur Créer.

    5. Notez client_id et client_secret pour les utiliser ultérieurement dans cette procédure.

  5. 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 client_id et client_secret obtenues lors des étapes précédentes.

    5. Sous Configurer votre application, cliquez sur Informations sur la configuration.

    6. Copiez les valeurs apiKey et authDomain dans le fichier static/config.js de l'exemple pour 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 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. Créez un dépôt Artifact Registry :

    gcloud artifacts repositories create REPOSITORY \
    --repository-format docker \
    --location REGION
    • REPOSITORY est le nom du dépôt. Pour chaque emplacement de dépôt d'un projet, les noms de dépôt doivent être uniques.

  7. Générez l'image de conteneur à l'aide de Cloud Build :

    Node.js 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql

    Python 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/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 Artifact Registry.

      gcloud auth configure-docker

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

      mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql

  8. 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 REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/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)'

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

    1. Cliquez sur l'icône en forme de crayon à côté de votre ID client OAuth pour le modifier, sous le bouton Authorized redirect URIs click the Ajouter un URI.

    2. Dans le champ, copiez et collez l'URL suivante, puis cliquez sur le bouton Enregistrer en bas de la page.

    https://PROJECT_ID.firebaseapp.com/__/auth/handler

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

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

    gcloud run services delete SERVICE-NAME

    Où 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