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

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.

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

Vérifiez que la facturation est activée pour votre projet Google Cloud.

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

Vérifiez que la facturation est activée pour votre projet Google Cloud.

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

Rôles requis

Pour obtenir les autorisations nécessaires pour suivre le tutoriel, demandez à votre administrateur de vous accorder le rôle IAM Propriétaire (roles/owner) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

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 :

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

asia-east1 (Taïwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlande) Faibles émissions de CO₂
europe-southwest1 (Madrid)
europe-west1 (Belgique) Faibles émissions de CO₂
europe-west4 (Pays-Bas)
europe-west8 (Milan)
europe-west9 (Paris) Faibles émissions de CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Faibles émissions de CO₂
us-east1 (Caroline du Sud)
us-east4 (Virginie du Nord)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Faibles émissions de CO₂

Soumis aux tarifs de niveau 2

africa-south1 (Johannesburg)
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-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (Londres, Royaume-Uni) Faibles émissions de CO₂
europe-west3 (Francfort, Allemagne) Faibles émissions de CO₂
europe-west6 (Zurich, Suisse) Faibles émissions de CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montréal) Faibles émissions de CO₂
northamerica-northeast2 (Toronto) Faibles émissions de CO₂
southamerica-east1 (São Paulo, Brésil) Faibles émissions de CO₂
southamerica-west1 (Santiago, Chili) Faibles émissions de CO₂
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 :

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.

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.

Un utilisateur final envoie la première requête au serveur Cloud Run.
Le client se charge dans le navigateur.
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é.
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.
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 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]:
    """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.

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

Accéder à la page Identity Platform Marketplace
Cliquez sur Activer Identity Platform.
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. Cliquez sur Configurer l'écran de consentement.
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 les coordonnées du développeur.
6. Cliquez sur Save and Continue (Enregistrer et continuer).
7. Dans la boîte de dialogue Champs d'application et test d'utilisateur, cliquez sur Enregistrer et continuer.
8. Cliquez sur Revenir au tableau de bord.
9. Sous État de publication, cliquez sur Publier l'application.
10. Cliquez sur Confirmer.
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 Create Credentials (Créer des identifiants), puis sélectionnez OAuth client ID.
3. Dans Type d'application, sélectionnez Application Web et indiquez le nom.
4. Notez les valeurs client_id et client_secret en vue d'une utilisation ultérieure dans cette procédure.
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 aux é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" :

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

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"
}

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

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

Attribuez des rôles pour l'accès à Secret Manager et à Cloud SQL à l'aide de la console ou de la CLI :

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

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

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

Remarque : Les variables d'environnement sont résolues au moment du démarrage de l'instance. Ainsi, si vous utilisez cette méthode, Google vous recommande d'épingler le secret à une version particulière plutôt que d'utiliser la dernière dernière version.

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 :

Modifiez le fournisseur Google en cliquant sur l'icône Stylo de la page Fournisseurs d'identité.
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)'
```
Accéder à la page API et services > Identifiants.
1. Cliquez sur l'icône en forme de crayon à côté de l'ID client OAuth pour le modifier, puis sur 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 au bas de la page.
```
https://PROJECT_ID.firebaseapp.com/__/auth/handler
```

Essayez-le !

Pour tester le service complet :

Accédez dans votre navigateur à l'URL fournie par l'étape de déploiement ci-dessus.
Cliquez sur le bouton Se connecter avec Google et suivez la procédure d'authentification.
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.

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 :

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
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

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.
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
```
Supprimez la configuration du projet :
```
 gcloud config unset project
```
Supprimez les autres ressources Google Cloud créées dans ce tutoriel :

Étape suivante

Découvrez plus en détail comment Se connecter à Cloud SQL à partir de Cloud Run.
En savoir plus sur les méthodes de connexion et la gestion des utilisateurs avec Identity Platform.
Découvrez d'autres moyens d'authentifier les développeurs, les services et les utilisateurs des services déployés dans Cloud Run.
Découvrez d'autres démonstrations, tutoriels et exemples concernant Cloud Run.

Tutoriel sur l'authentification des utilisateurs finaux pour Cloud Run

Objectifs

Coûts

Avant de commencer

Rôles requis

Configurer les valeurs par défaut pour gcloud

Emplacements Cloud Run

Soumis aux tarifs de niveau 1

Soumis aux tarifs de niveau 2

Récupérer l'exemple de code

Node.js

Python

Java

Node.js

Python

Java

Visualiser l'architecture

Comprendre le code principal

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

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

Node.js

Python

Java

Connecter le serveur à Cloud SQL

Node.js

Python

Java

Gérer une configuration sensible avec Secret Manager

Node.js

Python

Java

Configurer Identity Platform

Déployer le service

Node.js

Python

Java

Node.js

Python

Java

Touches finales

Essayez-le !

Nettoyer

Supprimer le projet

Supprimer les ressources du tutoriel

Étape suivante

Configurer les valeurs par défaut pour `gcloud`