Tutoriel sur l'authentification des utilisateurs finaux pour Cloud Run

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.

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

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

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);
  }
};

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

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

/**
 * 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,
  });
};

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

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

// 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}`
    );
  }
}

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)

/** 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'une des adresses e-mail d'assistance utilisateur affichées.
      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 Utilisateurs de test, cliquez sur Enregistrer et continuer.

   9. Dans la boîte de dialogue Résumé, cliquez sur Revenir 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, puis indiquez un nom.

   4. Cliquez sur Créer.

   5. Notez client_id et client_secret pour les utiliser plus tard 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 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" :

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 Save (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 :

   

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.