Cette page a été traduite par l'API Cloud Translation.

Authentifier les utilisateurs

Cette page explique comment permettre l'authentification des utilisateurs dans votre API à partir d'applications clientes utilisant Cloud Endpoints Frameworks. Sachez que les clients Android et JavaScript sont actuellement compatibles.

Cloud Endpoints Frameworks accepte l'authentification des utilisateurs à partir d'applications clientes utilisant l'une des méthodologies suivantes :

Quelle que soit la méthode d'authentification employée, dans chaque méthode d'API pour laquelle vous souhaitez confirmer que l'authentification est appropriée, vous devez rechercher un élément User valide, comme décrit dans les sections suivantes :

Procéder à l'authentification via la fonctionnalité d'authentification de Firebase
Procéder à l'authentification via Auth0
Procéder à l'authentification via les jetons d'ID Google

Prérequis

Cette page suppose que vous avez déjà :

créé un projetGoogle Cloud ;
ajouté la gestion de l'API.

Procéder à l'authentification via la fonctionnalité d'authentification de Firebase

Pour pouvoir gérer les appels de clients utilisant l'authentification Firebase :

Si vous ne l'avez pas déjà fait, créez un projet Firebase. Les projets Firebase sont des projets de la console Google Cloud qui utilisent les services Firebase. Pour en savoir plus, consultez la page Qu'est-ce qu'un projet Firebase ? ainsi que la documentation Firebase.
Ajoutez les éléments suivants à votre annotation de méthode ou @Api :
- Ajoutez à l'annotation un paramètre authenticators défini sur la valeur {EspAuthenticator.class}.
- Ajoutez un paramètre issuers contenant un élément @ApiIssuer défini sur Firebase.
- Ajoutez un paramètre issuerAudiences contenant un élément @ApiIssuerAudience défini sur Firebase et l'ID du projet.
Exemple :
```
@Api(
    name = "YOUR_API_NAME",
    version = "VERSION_NUMBER",
    authenticators = {EspAuthenticator.class},
    issuers = {
        @ApiIssuer(
            name = "firebase",
            issuer = "https://securetoken.google.com/YOUR_PROJECT_ID",
            jwksUri = "https://www.googleapis.com/service_accounts/v1/metadata/x509/securetoken@system.gserviceaccount.com")
    },
    issuerAudiences = {
        @ApiIssuerAudience(name = "firebase", audiences = "YOUR_PROJECT_ID")
    })
```
- Remplacez YOUR_API_NAME par le nom de votre API.
- Remplacez VERSION_NUMBER par la version de votre API, par exemple, v1.
- Remplacez les deux instances de YOUR_PROJECT_ID par l'ID du projet Firebase.
Dans le code de mise en œuvre de l'API, importez Users :
```
import com.google.api.server.spi.auth.common.User;
```

Dans chaque méthode API pour laquelle vous souhaitez vérifier que l'authentification est appropriée, recherchez un élément User valide. S'il n'y en a pas, générez une exception comme indiqué dans cet exemple de définition de méthode :

@ApiMethod(httpMethod = ApiMethod.HttpMethod.GET)
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}

Redéployez l'API à chaque ajout de nouveaux clients.

Ajouter l'authentification Firebase à un client

Vous pouvez ajouter l'authentification Firebase à votre code comme décrit dans la documentation Firebase. Le client doit être associé à un projet Google Cloud , et l'ID du projet doit être répertorié dans la configuration d'émetteur Firebase de l'API, comme indiqué dans la section précédente.

Procéder à l'authentification via Auth0

Pour pouvoir gérer les appels de clients utilisant Auth0 :

Ajoutez les éléments suivants à votre annotation de méthode ou @Api :
- Ajoutez à l'annotation un paramètre authenticators défini sur la valeur {EspAuthenticator.class}.
- Ajoutez un paramètre issuers contenant un élément @ApiIssuer défini sur Auth0.
- Ajoutez un paramètre issuerAudiences contenant un élément @ApiIssuerAudience défini sur Auth0 et l'ID client Auth0.
Exemple :
```
@Api(
    name = "YOUR_API_NAME",
    version = "VERSION_NUMBER",
    authenticators = {EspAuthenticator.class},
    issuers = {
        @ApiIssuer(
            name = "auth0",
            issuer = "https://YOUR_ACCOUNT_NAME.auth0.com/",
            jwksUri = "https://YOUR_ACCOUNT_NAME.auth0.com/.well-known/jwks.json")
     },
     issuerAudiences = {
         @ApiIssuerAudience(name = "auth0", audiences = "AUTH0_CLIENT_ID")
    })
```
- Remplacez YOUR_API_NAME par le nom de votre API.
- Remplacez VERSION_NUMBER par la version de votre API, par exemple, v1.
- Remplacez YOUR_ACCOUNT_NAME par le nom de compte Auth0 utilisé pour le client.
- Remplacez AUTH0_CLIENT_ID par l'ID que vous souhaitez utiliser pour votre client.
Dans le code de mise en œuvre de l'API, importez Users :
```
import com.google.api.server.spi.auth.common.User;
```

@ApiMethod(httpMethod = ApiMethod.HttpMethod.GET)
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}

Redéployez l'API à chaque ajout de nouveaux clients.

Ajouter l'authentification Auth0 à un client

Vous pouvez ajouter l'authentification Auth0 à votre code comme décrit dans la documentation Auth0. Le client doit être répertorié dans la configuration d'émetteur Auth0 de l'API.

Procéder à l'authentification via les jetons d'ID Google

Pour pouvoir gérer les appels de clients qui s'authentifient à l'aide de jetons d'ID Google :

Obtenez un ID client OAuth 2.0 pour chaque application cliente. Le propriétaire de l'application cliente doit générer l'ID client à partir de la console Google Cloud . Pour obtenir des instructions, consultez la page Créer des ID client.
Ajoutez une entrée clientIds contenant l'ID client pour chaque application cliente à laquelle vous accordez l'accès, ainsi qu'une entrée audiences pour chaque client Android, dans votre annotation @Api.

Exemple :
```
@Api(
   name = "YOUR_API_NAME",
   version = "VERSION_NUMBER",
   clientIds = {"YOUR_CLIENT_ID"},
   audiences = {"YOUR_CLIENT_ID"}
)
```
- Remplacez YOUR_API_NAME par le nom de votre API.
- Remplacez VERSION_NUMBER par la version de votre API, par exemple, v1.
- Remplacez YOUR_CLIENT_ID par l'ID client OAuth 2.0 généré dans le projet de l'application cliente.
Dans le code de mise en œuvre de l'API, importez Users :
```
import com.google.api.server.spi.auth.common.User;
```

@ApiMethod(httpMethod = ApiMethod.HttpMethod.GET)
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}

Redéployez l'API à chaque ajout de nouveaux clients.

Ajouter l'authentification via des jetons d'ID Google à un client

Pour plus d'informations sur l'ajout de code d'authentification aux clients, consultez les articles suivants :

Application Android

Envoyer un jeton JWT au client

Si vous utilisez un jeton JWT dans le client pour envoyer des requêtes authentifiées à l'API, ce jeton doit figurer dans l'en-tête d'autorisation d'une requête HTTP. Il doit avoir les revendications requises suivantes :

iss
sub
aud
iat
exp

Étape suivante

Pour obtenir des informations générales sur l'authentification des utilisateurs et les différences avec l'autorisation via des clés API, consultez la page Quand et pourquoi utiliser les clés API.

Authentifier les utilisateurs Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.