Présentation : API OAuth

Présentation

La mise en œuvre de Brightcove se compose de deux parties :

L'API OAuth - permet d'accéder à toutes les fonctionnalités OAuth disponibles
L'interface utilisateur des informations d'identification OAuth - accessible via l'interface Paramètres du compte de Studio, l'interface utilisateur fournit un moyen facile d'enregistrer des applications qui utiliseront les API Brightcove et génèrent un ID client et un secret client pour elles. Pour obtenir des instructions sur l'utilisation de l'interface utilisateur OAuth, reportez-vous à la section Gestion des informations d'authentification API

Glossaire des termes

OAuth: Une norme ouverte pour l'autorisation. Cette norme fournit aux applications clients un « accès délégué sécurisé » aux ressources du serveur au nom d'un propriétaire de ressources. OAuth permet essentiellement d'émettre des jetons d'accès à des clients tiers par un serveur d'autorisation, avec l'approbation du propriétaire de la ressource. Le client utilise ensuite le jeton d'accès pour accéder aux ressources protégées hébergées par le serveur de ressources
portée: Objet de données décrivant un ensemble de ressources (accessible via une API) et certaines opérations sur ces ressources (telles que « lire » et « écrire »). La portée d'un jeton d'accès limite ce que vous pouvez faire en présentant ce jeton.
client: Application utilisée par un utilisateur final pour accéder à une ressource via une API Brightcove.
ID client: Identifiant unique pour un client généré par le service OAuth.
secret client: Chaîne de bits qui, utilisée avec un identifiant client, sert de mot de passe pour authentifier un client.
jeton d'accès: Chaîne de bits qui fournit un accès temporaire à une API. Les jetons d'accès sont renvoyés par le service OAuth pour un client sur demande.
flux: Séquence d'opérations qui permet d'accéder avec succès à une ressource protégée par OAuth-OAuth.

URL de base

L'URL de base de l'API OAuth est :

    https://oauth.brightcove.com/v4

Flux d'informations d'identification client

Dans le flux d'informations d'identification client, votre application fera une demande pour un jeton d'accès, en transmettant votre identifiant client et le secret client au service OAuth avec la demande. Actuellement, il s'agit du seul flux pris en charge pour les clients Brightcove.

Le fonctionnement exact du flux d'informations d'identification client dépendra du scénario.

Application organisationnelle

Dans ce scénario, vous disposez d'une application qui doit interagir avec une ou plusieurs API Brightcove, uniquement pour le ou les comptes appartenant à votre organisation. L'application n'est liée à aucun utilisateur spécifique. Dans ce cas, le flux de travail ressemble à ceci :

Workflow d'informations d'identification client pour l'application d'organisation

Pour implémenter ce scénario, procédez comme suit :

À l'aide de l'interface utilisateur OAuth ou du service OAuth, obtenez un identifiant client et un secret pour votre application - l'interface utilisateur vous permet d'obtenir un identifiant client et un secret pour un seul compte ou plusieurs. Il s'agit d'une opération unique.
Ajoutez une logique à votre application côté serveur pour faire des demandes à l'API OAuth pour les jetons d'accès. L'implémentation dépendra de la langue de votre application (et nous vous encourageons à utiliser une bibliothèque OAuth2 existante pour votre langue si possible), mais l'appel que vous passerez sera une requête POST à :
```
    https://oauth.brightcove.com/v4/access_token
    
    
```
Les client_id et client_secret sont passés en tant que username:password dans un en-tête d'autorisation de base :
```
    Authorization: Basic {client_id}:{client_secret}
    
    
```
La {client_id}:{client_secret} chaîne entière doit être codée en Base64 (dans Node.js, par exemple, vous pouvez utiliser la Buffer.toString("base64") méthode). CURL effectue le codage BASE64 automatiquement, de sorte que vous pouvez simplement passer les informations d'identification comme user {client_id}:{client_secret}. Vous devez également inclure un Content-Type: application/x-www-form-urlencoded en-tête.

Le corps de la requête contiendra la paire clé/valeur grant_type=client_credentials. Notez que depuis l' Content-type est x-www-form-urlencoded , vous pouvez également ajouter ceci à l'URL de la requête en tant que paramètre :
```
    https://oauth.brightcove.com/v4/access_token?grant_type=client_credentials
```
Voici une application Node.js très basique qui obtiendra un access_token donné un valide client_id et client_secret.
```
    /*
    * Simple node app to get an access_token for a Brightcove API
    * You will need to substitute valid client_id and client_secret values
    * for {your_client_id} and {your_client_secret}
    */
    var request = require('request');
    var client_id = "{your_client_id}";
    var client_secret = "{your_client_secret}";
    var auth_string = new Buffer(client_id + ":" + client_secret).toString('base64');
    console.log(auth_string);
    request({
    method: 'POST',
    url: 'https://oauth.brightcove.com/v4/access_token',
    headers: {
    'Authorization': 'Basic ' + auth_string,
    'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: 'grant_type=client_credentials'
    }, function (error, response, body) {
    console.log('Status: ', response.statusCode);
    console.log('Headers: ', JSON.stringify(response.headers));
    console.log('Response: ', body);
    console.log('Error: ', error);
    });
    
    
```

Le corps de réponse ressemblera à ce qui suit :

    {
    "access_token": "ACikM-7Mu04V5s7YBlKgTiPu4ZO3AsTBlWt-73l5kXRN4IeRuIVlJHZkq_lFQdZBYfzT9B_nHNgcmNFdalxSiNdqOBaaV7wQCCnRCua_efHNCg9d_yLbezcjxr3AGcBKy9a8_t-uTMTA46T24LKMOBGBNJFkyATSZI4JuxU71VIyGF9hDisbKHmKC5G5HdQ0nJgyCD1w1zkKrB1CpFb5iiBuA_XOzehF-Xf5DBYnSkDhzzByuFwTv9dU9d7W6V2OuiKiTzCzY3st01qJTk6-an6GcAOD4N5pdN8prvvMDQhz_HunJIamvVGqBz7o3Ltw8CFFJMXKQdeOF8LX31BDnOvMBEz-xvuWErurvrA0r6x5eZH8SuZqeri4ryZAsaitHiJjz9gp533o",
    "token_type": "Bearer",
    "expires_in": 300
    }

Vous devrez capturer le access_token. À moins que vos appels soient intermittents, auquel cas vous demanderez un nouveau access_token pour chaque appel d'API, vous voudrez également capturer la expires_in valeur afin que vous puissiez l'utiliser pour des requêtes ultérieures afin de vérifier si votre jeton est toujours valide - sinon, vous devrez en demander un nouveau. La expires_in valeur est exprimée en secondes.

Une fois que vous avez le access_token, vous pouvez appeler l'API Brightcove, y compris le jeton dans l' Authorization en-tête sous la forme :
```
    Authorization: Bearer {access_token}
    
    
```

Voir Obtenir des jetons d'accès pour plus de détails et des exemples de code.

Autorisation générale

Ce scénario s'applique principalement aux partenaires Brightcove qui créeront des applications pouvant être utilisées par les utilisateurs de Brightcove au sein de diverses organisations. Le flux de travail pour ce scénario ressemble à ce qui suit :

Workflow des informations d'identification client pour l'application multi-organisation — Flux de travail des informations d'identification client pour l'application multi-organisation

La seule différence dans l'implémentation de ce scénario plutôt que le premier est que l'utilisateur doit obtenir un identifiant client et un secret pour votre application à partir de l'interface utilisateur OAuth et vous les fournir via un formulaire. Vous les transmettrez ensuite à votre application pour soumettre avec la demande d'un access_token. A part cela, tout sera pareil.

Obtenir les identifiants client

Le moyen le plus simple d'obtenir les informations d'identification client ( client_id et client_secret ) est d'utiliser l' interface utilisateur OAuth. Si vous préférez les obtenir directement à partir du Service OAuth, vous pouvez le faire en faisant une requête POST à https://oauth.brightcove.com/v4/client_credentials, en passant les en-têtes suivants :

Content-Type: application/json
Authorization: BC_TOKEN your BC_TOKEN

Vous devez également envoyer un objet JSON comme charge utile :

    {
      "type": "credential",
      "maximum_scope": [
        {
          "identity": {
            "type": "video-cloud-account",
            "type": "perform-account",
            "account-id": account_id1
          },
          "operations": [
            "video-cloud/player/all"
          ]
        },
        {
          "identity": {
          "type": "video-cloud-account",
          "type": "perform-account",
          "account-id": account_id2
        },
        "operations": [
          "video-cloud/player/all"
        ]
        }
      ],
      "name": "AnalyticsClient",
      "description": "My analytics app"
    }

Opérations

La seule chose qui varie ici est la operations valeur, qui dépendra de l'API à laquelle vous voulez accéder, et si vous voulez accéder à la lecture, à l'écriture ou aux deux opérations. Consultez la section Opérations API pour les demandes d'informations d'identification client pour obtenir la liste de toutes les opérations actuellement prises en charge.

Pour obtenir des guides détaillés sur l'obtention des informations d'identification client à l'aide de curl ou Postman, voir :

Travailler avec OAuth

Pour construire une logique pour gérer l'obtention de jetons d'accès pour vos requêtes API, il existe deux façons générales de procéder.

Si vous créez une seule application côté serveur, il est logique de construire la logique dans l'application. La séquence d'opérations ressemblera à ceci :

Si vous créez plusieurs applications qui auront besoin d'appeler les API Brightcove, ou si vous créez une application Web côté client, il est plus logique de consolider le code pour obtenir des jetons d'accès en un seul proxy. Dans ce cas, la séquence d'opérations ressemblera à ceci :

Reportez-vous au Quick Start pour obtenir des instructions détaillées sur la création d'un proxy simple.

Échantillons et bibliothèques de clients

Nous avons créé des exemples d'implémentations de clients dans plusieurs langues pour vous donner des modèles pour les implémentations.

Il existe également des bibliothèques OAuth2 disponibles pour un certain nombre de langues, et nous vous encourageons généralement à utiliser ces bibliothèques dans la mesure du possible, plutôt que de créer une interaction avec l'API OAuth. Voici une liste partielle des bibliothèques disponibles. Pour une liste plus complète, voir http://oauth.net/2/

Python

PHP

Cacao

Cacao

iOS

iPhone et iPad

iOS et Mac macOS

iOS et Mac macOS

Java

Ruby

.NET

Qt/C++

O2