# Exemples par langage backend

DRM-X 6.0 modèles d'intégration de backend pour PHP, ASP.NET Core, Node.js, Python, Java, Go et Ruby en utilisant une session de lecture sécurisée API.

Comment la lecture est autorisée

Votre backend décide qui peut regarder le contenu. DRM-X fournit l’autorisation de lecture. Le lecteur l’utilise pour demander une licence DRM.

- 01**Spectateur**

Se connecte à votre service et demande une vidéo.

- 02**Votre backend**

Vérifie l’achat, l’abonnement ou toute autre autorisation d’accès de l’utilisateur.

- 03**DRM-X**

Applique les règles choisies et renvoie la configuration ainsi que l’autorisation de lecture.

- 04**Lecteur**

Utilise l’autorisation reçue pour demander la licence DRM nécessaire à la lecture.

Votre moteur décide de l'accès; DRM-X applique la politique signée. Les licences de médias chiffrés et DRM suivent des chemins de livraison séparés.

## La requête indépendante de la langue[#](#the-language-independent-request)

```
POST /api/v1/playback/environments/{siteId}/sessions
X-DRMX-Client-Id: {siteKey}
X-DRMX-Client-Secret: {accessKey}

{
  "contentId": "trusted-content-id",
  "contentType": "vod",
  "drmSystem": "widevine",
  "subject": "authenticated-user-id",
  "sessionId": "new-id-for-this-attempt",
  "licensePolicyTemplate": "multi-tier-standard",
  "useEnvironmentDefaults": true
}
```



## Choisissez votre moteur de recherche [#](#choose-your-backend)

### PHP 8.2+

Utilisez cURL avec des exceptions JSON, HTTPS- seulement des protocoles, un délai de traitement de 12 secondes, et un état de réponse explicite. L'application complète PHP comprend connexion, droit, jeton direct, jeton-proxy, diagnostic et libération.

[Exécuter l'échantillon PHP](https://developer.drm-x.com/php-sample/)

### ASP.NET Core

Utilisez la validation des options fournies, tapé `HttpClient`, annulation, `JsonContent` et helper d'extrémité. Les valeurs de configuration sont claires en code pour la première exécution avec des alternatives de gestion secrète commentées.

### Node.js / TypeScript

Utilisez `fetch` avec `AbortSignal.timeout`, configuration uniquement pour le serveur, validation du schéma de réponse et `Cache-Control: no-store`.

### Python 3.11+

Utilisez un client HTTPS avec des timeouts explicites, JSON sérialisation, contrôles d'état, et injection secrète à partir de l'exécution de production.

### Java 21+

Utilisez `HttpClient` avec timeout de requête, en-têtes exacts, validés JSON, et aucune redirection vers des origines méfiantes.

### Allez ou Ruby

Utilisez un contexte/timeout de requête, des champs JSON exacts, des contrôles d'état stricts, et n'imprimez jamais de corps de réponse de reconnaissance ou de lecture réussie.



## Carte des valeurs commerciales en toute sécurité[#](#map-business-values-safely)

| Champ de demande | Source | 
| --- | --- |

| `contentId` | Carte de serveur de votre catalogue vers un fichier protégé Publié. | 

| `subject` | Votre utilisateur authentifié ID; jamais une identité fournie par le navigateur. | 

| `licensePolicyTemplate` | Carte de serveur à partir d'un plan de confiance, location, cours, ou niveau de contenu. | 

| `drmSystem` | Capacité client validée, limitée aux systèmes DRM de votre intégration. | 

| `sessionId` | Un nouvel identifiant imprévisible créé par votre moteur pour cette tentative de lecture. | 



## Utiliser des valeurs de code direct uniquement pour la première exécution [# ](#use-direct-code-values-only-for-the-first-run)

Pour la production, décommentez l'option documentée environnement/secret-manager, supprimez les secrets codés en dur, faites pivoter le client et n'accordez que `license-tokens:create`.



Didacticiels de serveur 

## Appelez le même paramètre à partir des langages populaires de backend[#](#call-the-same-endpoint-from-popular-backend-languages)



Dans chaque exemple, authentifiez le spectateur et vérifiez le droit avant cet appel. PHP et ASP.NET montrent des valeurs de code direct pour la première exécution; déplacez le Access Key vers un gestionnaire secret pour la production et ne logez jamais les en-têtes de requête ou le corps de réponse réussi.

PHP 8.2+



```
$drmx = [
    'platformApi' => 'https://api6.drm-x.com',
    'siteId' => 'your-development-environment-uuid',
    'siteKey' => 'drmx_your_environment_scoped_client_id',
    'accessKey' => 'paste-your-one-time-access-key',
];

$payload = [
    'contentId' => $trustedContentId,
    'contentType' => 'vod',
    'drmSystem' => $drmSystem,
    'subject' => $authenticatedUserId,
    'playbackMode' => 'streaming',
    'licensePolicyTemplate' => 'multi-tier-standard',
    'useEnvironmentDefaults' => true,
    'maximumQualityTier' => 'auto',
];

$curl = curl_init($drmx['platformApi'] . '/api/v1/playback/environments/' .
    rawurlencode($drmx['siteId']) . '/sessions');
curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 12,
    CURLOPT_PROTOCOLS => CURLPROTO_HTTPS,
    CURLOPT_HTTPHEADER => [
        'Accept: application/json',
        'Content-Type: application/json',
        'X-DRMX-Client-Id: ' . $drmx['siteKey'],
        'X-DRMX-Client-Secret: ' . $drmx['accessKey'],
    ],
]);
$body = curl_exec($curl);
```



Commencez à partir de l'échantillon exécutable complet; il comprend la connexion, le droit, le mode de jeton direct, le mode de jeton-proxy, le diagnostic limité et la manipulation de la libération.

Node.js / TypeScript



```
const response = await fetch(
  `${process.env.DRMX_PLATFORM_API}/api/v1/playback/environments/${
    encodeURIComponent(process.env.DRMX_PLAYBACK_SITE_ID!)
  }/sessions`,
  {
    method: "POST",
    headers: {
      "Accept": "application/json",
      "Content-Type": "application/json",
      "X-DRMX-Client-Id": process.env.DRMX_PLAYBACK_SITE_KEY!,
      "X-DRMX-Client-Secret": process.env.DRMX_PLAYBACK_ACCESS_KEY!,
    },
    body: JSON.stringify({
      contentId: trustedContentId,
      contentType: "vod",
      drmSystem,
      subject: authenticatedUser.id,
      playbackMode: "streaming",
      licensePolicyTemplate: "multi-tier-standard",
      useEnvironmentDefaults: true,
      maximumQualityTier: "auto",
    }),
    signal: AbortSignal.timeout(12_000),
  },
);
const playback = await response.json();
```

Python 3.11+



```
import json, os, urllib.request

payload = json.dumps({
    "contentId": trusted_content_id,
    "contentType": "vod",
    "drmSystem": drm_system,
    "subject": authenticated_user_id,
    "playbackMode": "streaming",
    "licensePolicyTemplate": "multi-tier-standard",
    "useEnvironmentDefaults": True,
    "maximumQualityTier": "auto",
}).encode("utf-8")

url = (
    os.environ["DRMX_PLATFORM_API"] +
    "/api/v1/playback/environments/" +
    os.environ["DRMX_PLAYBACK_SITE_ID"] + "/sessions"
)
request = urllib.request.Request(url, data=payload, method="POST", headers={
    "Accept": "application/json",
    "Content-Type": "application/json",
    "X-DRMX-Client-Id": os.environ["DRMX_PLAYBACK_SITE_KEY"],
    "X-DRMX-Client-Secret": os.environ["DRMX_PLAYBACK_ACCESS_KEY"],
})
with urllib.request.urlopen(request, timeout=12) as response:
    playback = json.load(response)
```

ASP.NET Core / C#



```
builder.Services.AddDrmXPlayback(options =>
{
    options.PlatformApi = "https://api6.drm-x.com";
    options.SiteId = "your-development-environment-uuid";
    options.SiteKey = "drmx_your_environment_scoped_client_id";
    options.AccessKey = "paste-your-one-time-access-key";
    options.ApplicationId = "customer-aspnet-website";
    options.LicensePolicyTemplate = "multi-tier-standard";
});

var payload = new {
    contentId = trustedContentId,
    contentType = "vod",
    drmSystem,
    subject = authenticatedUserId,
    playbackMode = "streaming",
    licensePolicyTemplate = "multi-tier-standard",
    useEnvironmentDefaults = true,
    maximumQualityTier = "auto"
};

using var request = new HttpRequestMessage(HttpMethod.Post,
    $"{platformApi}/api/v1/playback/environments/{Uri.EscapeDataString(siteId)}/sessions") {
    Content = JsonContent.Create(payload)
};
request.Headers.Add("X-DRMX-Client-Id", siteKey);
request.Headers.Add("X-DRMX-Client-Secret", accessKey);
using var response = await httpClient.SendAsync(request, cancellationToken);
```

Java 21 / Services de printemps



```
String payload = objectMapper.writeValueAsString(Map.of(
    "contentId", trustedContentId,
    "contentType", "vod",
    "drmSystem", drmSystem,
    "subject", authenticatedUserId,
    "playbackMode", "streaming",
    "licensePolicyTemplate", "multi-tier-standard",
    "useEnvironmentDefaults", true,
    "maximumQualityTier", "auto"
));

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create(platformApi + "/api/v1/playback/environments/" +
        URLEncoder.encode(siteId, StandardCharsets.UTF_8) + "/sessions"))
    .timeout(Duration.ofSeconds(12))
    .header("Accept", "application/json")
    .header("Content-Type", "application/json")
    .header("X-DRMX-Client-Id", siteKey)
    .header("X-DRMX-Client-Secret", accessKey)
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();
HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());
```

Aller 1.23+



```
payload, _ := json.Marshal(map[string]any{
    "contentId": trustedContentID,
    "contentType": "vod",
    "drmSystem": drmSystem,
    "subject": authenticatedUserID,
    "playbackMode": "streaming",
    "licensePolicyTemplate": "multi-tier-standard",
    "useEnvironmentDefaults": true,
    "maximumQualityTier": "auto",
})

url := platformAPI + "/api/v1/playback/environments/" +
    url.PathEscape(siteID) + "/sessions"
req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(payload))
req.Header.Set("Accept", "application/json")
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-DRMX-Client-Id", siteKey)
req.Header.Set("X-DRMX-Client-Secret", accessKey)
response, err := httpClient.Do(req)
```

Ruby 3.3+



```
uri = URI("#{ENV.fetch('DRMX_PLATFORM_API')}/api/v1/playback/environments/" \
          "#{ERB::Util.url_encode(ENV.fetch('DRMX_PLAYBACK_SITE_ID'))}/sessions")
request = Net::HTTP::Post.new(uri)
request['Accept'] = 'application/json'
request['Content-Type'] = 'application/json'
request['X-DRMX-Client-Id'] = ENV.fetch('DRMX_PLAYBACK_SITE_KEY')
request['X-DRMX-Client-Secret'] = ENV.fetch('DRMX_PLAYBACK_ACCESS_KEY')
request.body = JSON.generate(
  contentId: trusted_content_id,
  contentType: 'vod',
  drmSystem: drm_system,
  subject: authenticated_user_id,
  playbackMode: 'streaming',
  licensePolicyTemplate: 'multi-tier-standard',
  useEnvironmentDefaults: true,
  maximumQualityTier: 'auto'
)
response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
```

<!-- Canonical: https://docs.drm-x.com/fr/integrations/backend-languages -->
<!-- Language: fr -->