Comprendre le flux de communication

Vous pouvez souhaiter qu'une application communique avec un autre service ou une autre application sans aucune intervention de l'utilisateur, pour plusieurs raisons. Par exemple, une application non interactive qui doit accéder à une autre application pour effectuer son travail. Cela peut inclure des processus, des interfaces de ligne de commande, des démons ou un terminal IoT qui surveille et transmet des variables d'environnement à un serveur en amont. Le cas d'utilisation spécifique est propre à chaque application, mais le plus important à retenir est que les demandes sont échangées au nom de l'application, et non d'un utilisateur final, et que c'est l'application qui est authentifiée et autorisée.

A quoi ressemble le flux ?

Dans l'image suivante, vous pouvez voir le sens de la communication entre le service et votre application.

1. Vous enregistrez l'application qui doit s'authentifier pour accéder à une ressource protégée avec App ID.
2. L'application A s'enregistre auprès d'App ID pour obtenir un ID client et un secret.
3. L'application A fait une demande au noeud final /token du serveur d'autorisation App ID en envoyant les données d'identification extraites à l'étape précédente.
4. App ID valide la demande, authentifie l'application et renvoie à l'application A une réponse contenant un jeton d'accès.
5. L'application A est maintenant capable d'utiliser le jeton d'accès valide pour envoyer des requêtes à des ressources protégées telles que l'application B.

Le secret client utilisé pour authentifier le client est très sensible et doit rester confidentiel. Étant donné que l'application utilise le secret du client dans l'application, ce flux de travail ne doit être utilisé qu'avec des applications de confiance. L'utilisation d'une application de confiance garantit que le secret client n'est pas divulgué ou mal utilisé.

Enregistrement de votre application

Obtention d'un jeton d'accès

Lorsque votre application est enregistrée auprès d'App ID et que vous avez obtenu vos données d'identification, vous pouvez envoyer une demande au serveur d'autorisations App ID pour obtenir un jeton d'accès.

1. Effectuer une requête HTTP POST vers le point de terminaison /token L'autorisation pour la demande est Basic auth, avec l'ID client et le secret utilisés comme nom d'utilisateur et mot de passe codés en base64.

   curl -X POST https://<region>.appid.cloud.ibm.com/oauth/v4/<tenantID>/token \
      -H 'Authorization: Basic base64Encoded{clientId:secret}' \
      -H 'Content-Type: application/x-www-form-urlencoded' \
      -d 'grant_type=client_credentials'
   

   Exemple de réponse :

   {
   "access_token": "eyJhbGciOiJS...F9A",
   "expires_in": "3600",
   "token_type": "Bearer"
   }
   

Tutoriel : flux de bout en bout avec le logiciel SDK Node.js

1. Obtenez un jeton d'accès de l'une des manières suivantes :

   • A partir du App ID Node.js server SDK en utilisant le gestionnaire de jetons. Initialisez le gestionnaire de jetons avec les données d'identification de votre application et appelez la méthode getApplicationIdentityToken() pour obtenir le jeton.

     const TokenManager = require('ibmcloud-appid').TokenManager;
     const config = {
     clientId: "<clientID>",
     tenantId: "<tenantID>",
     secret: "{secret}",
     oauthServerUrl: "https://<region>.appid.cloud.ibm.com/oauth/v4/<tenantID>"
     };
     const tokenManager = new TokenManager(config);
     tokenManager.getApplicationIdentityToken().then((appIdAuthContext) => {
     console.log(' Access tokens from SDK : ' + JSON.stringify(appIdAuthContext));
     }).catch((err) => {
     //console.error('Error retrieving tokens : ' + err);
     });
     

   • A partir du serveur d'autorisations App ID.

     L'URL oauthServerUrl contenue dans la demande est obtenue lors de l'enregistrement de votre application. Si vous avez enregistré votre application avec les API de gestion, l'URL du serveur se trouve dans le corps de la réponse. Si vous avez enregistré votre application en la liant à la console IBM Cloud, l'URL se trouve dans votre objet VCAP_SERVICES JSON ou dans vos valeurs confidentielles Kubernetes.

     var request = require('request');
     function getAccessToken() {
     let options = {
           method: 'POST',
           url: oauthServerUrl + '/token',
           headers: { 'content-type': 'application/x-www-form-urlencoded',
              'Authorization': 'Basic ' +Buffer.from('clientId: secret').toString('base64')
           },
           form: {
              grant_type: 'client_credentials'
           }
     };
     return new Promise((resolve, reject) => {
           request(options, function (error, response, body) {
              if (error) {
                 return reject(error);
              }
              let data = JSON.parse(body);
              if(data.access_token) {
                 resolve(data.access_token);
              } else {
                 reject(data);
              }
           })
     });
     }
     

2. Envoyez une demande à votre ressource protégée en utilisant le jeton d'accès obtenu à l'étape précédente.

   let options = {
      method: 'GET',
      url: 'http://localhost:8081/protected_resource',
      headers: { authorization : 'Bearer ' + accessToken}
   }
   request(options, function (error, response, body) {
      if (error) {
         console.log(error)
      } else {
            res.status(response.statusCode).send({
      console.log(JSON.stringify(body));
            });
      }
   });
   

3. Sécurisez vos ressources protégées à l'aide de la stratégie d'API du logiciel SDK Node.js App ID.

   const express = require('express'),
      passport = require('passport');
      APIStrategy = require("ibmcloud-appid").APIStrategy;
   var app = express();
   app.use(passport.initialize());
   passport.use(new APIStrategy({
      oauthServerUrl: "https://{region}.appid.cloud.ibm.com/oauth/v4/{tenant-ID}",
      tenantId:"{tenant-ID}"
   }));
   app.get('/protected_resource',
      passport.authenticate(APIStrategy.STRATEGY_NAME, {session: false}),
      (req, res) => {
            res.send("Hello from protected resource");
   });