Aperçu: OAuth API

Vue d'ensemble

La mise en œuvre de Brightcove comprend deux parties:

Le système d'implants dentaires OAuth API - donne accès à toutes les fonctionnalités OAuth disponibles
Interface utilisateur OAuth Credentials - accessible via l’interface Paramètres du compte dans Studio, elle permet d’enregistrer facilement les applications qui utiliseront les API Brightcove et de générer un identifiant client et un secret client. Voir Gestion des informations d'identification de l'API pour obtenir des instructions sur l'utilisation de l'interface utilisateur OAuth.

Glossaire des termes

OAuth: Une norme ouverte pour l'autorisation. OAuth fournit aux applications client un «accès délégué sécurisé» aux ressources du serveur pour le compte d'un propriétaire de ressource. OAuth autorise essentiellement l'émission de 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 "read" et "write"). La portée d'un jeton d'accès limite ce que vous pouvez faire en présentant ce jeton.
client: Une application utilisée par un utilisateur final pour accéder à une ressource via une API Brightcove.
identité du client: Un identifiant unique pour un client généré par le service OAuth.
secret client: Une chaîne de bits utilisée avec un identifiant client sert de mot de passe pour authentifier un client.
jeton d'accès: Une 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 permettant d'accéder à une ressource protégée par OAuth.

URL de base

L'URL de base pour le OAuth API est:

    https://oauth.brightcove.com/v4

Flux d'informations d'identification du client

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

La manière exacte dont le flux d'informations d'identification du client fonctionnera dépendra du scénario.

Application organisationnelle

Dans ce scénario, vous avez une application qui doit interagir avec une ou plusieurs API Brightcove, uniquement pour le compte 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:

Pour implémenter ce scénario, vous devez effectuer les opérations suivantes:

À l'aide de l'interface utilisateur OAuth ou du service OAuth, obtenez un identifiant client et un code secret pour votre application. L'interface utilisateur vous permet d'obtenir un identifiant client et un code secret pour un ou plusieurs comptes. Ceci est une opération unique.
Ajoutez de la logique à votre application côté serveur pour envoyer des requêtes au OAuth API pour les jetons d'accès. La mise en œuvre dépendra de la langue de votre application (et vous êtes encouragé à utiliser un logiciel existant. Bibliothèque OAuth2 pour votre langue si possible), mais l'appel que vous ferez sera une demande POST à:
```
    https://oauth.brightcove.com/v4/access_token
    
    
```
Le système d'implants dentaires 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}
    
    
```
L'ensemble {client_id}:{client_secret} string doit être codé Base64 (dans Node.js, par exemple, vous pouvez utiliser le Buffer.toString("base64") méthode). CURL fait l'encodage BASE64 automatiquement, donc 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 le Content-type is x-www-form-urlencoded, vous pouvez aussi simplement 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 la réponse ressemblera à ceci:

    {
    "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 ne soient intermittents, auquel cas vous demanderez une nouvelle access_token pour chaque appel API, vous souhaiterez également capturer expires_in valeur afin que vous puissiez l'utiliser pour les demandes ultérieures pour vérifier si votre jeton est toujours valide - sinon, vous devrez en demander un nouveau. le expires_in la valeur est en secondes.

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

Voir Obtenir des jetons d'accès pour plus de détails et d'échantillons 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 Brightcove dans diverses organisations. Le flux de travail pour ce scénario se présente comme suit:

Flux de travaux d'identification des clients pour une application multi-organisationnelle — Flux de travaux d'identification des clients pour une application multi-organisations

La seule différence dans la mise en œuvre 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 devrez ensuite les transmettre à votre application pour les soumettre avec la demande d'un access_token. En dehors de cela, tout sera pareil.

Obtenir des informations d'identification client

Le moyen le plus simple d'obtenir les informations d'identification du client (le client_id et client_secret) est d'utiliser le OAuth UI. Si vous préférez les obtenir directement auprès du service OAuth, vous pouvez le faire en envoyant 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 en tant que 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 va varier ici est le operations value, qui dépend de l'API à laquelle vous voulez accéder et de l'accès en lecture, en écriture ou des deux. Voir Opérations d'API pour les demandes d'informations d'identification du client pour une liste de toutes les opérations actuellement supportées.

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

Travailler avec OAuth

Pour créer une logique permettant de gérer les jetons d'accès pour vos demandes d'API, il existe deux façons générales de procéder.

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

Si, au contraire, vous allez créer plusieurs applications nécessitant des appels aux API Brightcove ou si vous créez une application Web côté client, il est plus logique de consolider le code pour obtenir les jetons d'accès dans un seul proxy. Dans ce cas, la séquence des opérations ressemblera à ceci:

Voir le Quick Start pour des instructions détaillées sur la création d'un proxy simple.

Échantillons de clients et bibliothèques

Nous avons créé exemple d'implémentation de client 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 lorsque cela est possible, plutôt que de créer une interaction avec le OAuth API. Vous trouverez ci-dessous 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