Remplacer la méthode d'authentification par défaut

Ce document explique comment remplacer l'authentification par défaut utilisée par Rust. Le code Rust authentifie automatiquement vos requêtes auprès des services Google Cloud , mais vous devrez peut-être remplacer vos identifiants par défaut de temps en temps.

Prérequis

Ce guide utilise l'API Cloud Natural Language. Pour installer cette API, suivez le guide de démarrage rapide du service, qui vous explique comment activer un service.

Pour obtenir des instructions de configuration complètes pour les bibliothèques Rust, consultez Premiers pas avec Rust.

Dépendances

Vous devez déclarer les dépendances dans votre fichier Cargo.toml :

cargo add google-cloud-language-v2 google-cloud-auth

Identifiants par défaut

La méthode recommandée pour authentifier les applications dans Google Cloud consiste à utiliser les Identifiants par défaut de l'application. Les bibliothèques clientes utilisent ce type d'identifiant par défaut, sans aucune configuration. Pour savoir comment configurer cette valeur par défaut sans modifier le code de votre application, consultez Fonctionnement des identifiants par défaut de l'application.

  1. Ajoutez des déclarations d'utilisation pour simplifier le reste de l'exemple : 

    use google_cloud_language_v2::client::LanguageService;
use google_cloud_language_v2::model::{Document, document::Type};

  2. Initialisez le client à l'aide des valeurs par défaut : 

    let client = LanguageService::builder().build().await?;

  3. Utilisez ce client comme d'habitude : 

    let response = client
    .analyze_sentiment()
    .set_document(
        Document::new()
            .set_content("Hello World!")
            .set_type(Type::PlainText),
    )
    .send()
    .await?;
println!("response={response:?}");

Remplacer les identifiants par défaut : clés API

Les clés API sont des chaînes de texte qui permettent d'accéder à certains services Google Cloud . L'utilisation de clés API peut simplifier le développement, car elles nécessitent moins de configuration que les autres méthodes d'authentification. Les clés API comportent certains risques. Nous vous recommandons de lire Bonnes pratiques pour gérer les clés API si vous prévoyez de les utiliser.

  1. Écrivez une fonction qui reçoit la chaîne de clé API en tant que paramètre d'entrée : 

    pub async fn sample(key: &str) -> anyhow::Result<()> {

  2. Ajoutez des déclarations d'utilisation pour simplifier le reste de l'exemple : 

    use google_cloud_auth::credentials::api_key_credentials::Builder as ApiKeyCredentialsBuilder;
use google_cloud_language_v2::client::LanguageService;
use google_cloud_language_v2::model::{Document, document::Type};

  3. Utilisez le générateur de clés API pour créer les identifiants : 

    let credentials = ApiKeyCredentialsBuilder::new(key).build();

  4. Initialisez le client à l'aide de l'objet credentials : 

    let client = LanguageService::builder()
    .with_credentials(credentials)
    .build()
    .await?;

  5. Utilisez ce client comme d'habitude : 

    let response = client
    .analyze_sentiment()
    .set_document(
        Document::new()
            .set_content("Hello World!")
            .set_type(Type::PlainText),
    )
    .send()
    .await?;
println!("response={response:?}");

Remplacer les identifiants par défaut : emprunt d'identité d'un compte de service

L'emprunt d'identité d'un compte de service vous permet d'effectuer des appels d'API au nom d'un compte de service. L'article Utiliser l'emprunt d'identité d'un compte de service décrit en détail cette forme d'authentification.

Lorsque vous utilisez l'emprunt d'identité d'un compte de service, vous commencez par un compte principal authentifié (votre compte Google ou un compte de service) et vous demandez des identifiants éphémères pour un compte de service disposant de l'autorisation requise par votre cas d'utilisation.

Cette méthode est plus sécurisée que le téléchargement d'une clé de compte de service pour le compte de service cible, car vous n'avez pas besoin de conserver les identifiants dans le système de fichiers ni même en mémoire.

  1. Écrivez l'exemple dans une fonction qui reçoit l'identifiant du compte de service en tant que paramètre d'entrée. Il peut s'agir de l'adresse e-mail du compte de service ou de l'identifiant numérique unique attribué par Google au compte de service. 

    /// # Parameters
/// * `target_principal`: the email or unique id of the target service account.
///   For example: `my-service-account@my-project.iam.gserviceaccount.com`.
pub async fn sample(target_principal: &str) -> anyhow::Result<()> {

  2. Ajoutez des déclarations d'utilisation pour simplifier le reste de l'exemple : 

    use google_cloud_auth::credentials::Builder as AdcCredentialsBuilder;
use google_cloud_auth::credentials::impersonated::Builder as ImpersonatedCredentialsBuilder;
use google_cloud_language_v2::client::LanguageService;
use google_cloud_language_v2::model::{Document, document::Type};

  3. Utilisez le Builder du compte de service emprunté pour créer les identifiants : 

    let credentials = ImpersonatedCredentialsBuilder::from_source_credentials(
    AdcCredentialsBuilder::default().build()?,
)
.with_target_principal(target_principal)
.build()?;

  4. Initialisez le client à l'aide de l'objet credentials : 

    let client = LanguageService::builder()
    .with_credentials(credentials)
    .build()
    .await?;

  5. Utilisez ce client comme d'habitude : 

    let response = client
    .analyze_sentiment()
    .set_document(
        Document::new()
            .set_content("Hello World!")
            .set_type(Type::PlainText),
    )
    .send()
    .await?;
println!("response={response:?}");

Plus d'infos

Découvrez d'autres méthodes d'authentification dans les bibliothèques clientes Rust :